package com.avaje.tests.query;

import javax.persistence.PersistenceException;

import com.avaje.ebean.*;
import com.avaje.tests.model.basic.Order;
import com.avaje.tests.model.basic.OrderShipment;
import org.avaje.ebeantest.LoggedSqlCollector;
import org.junit.Test;

import com.avaje.tests.model.basic.Customer;
import com.avaje.tests.model.basic.ResetBasicData;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class TestQueryFindIterate extends BaseTestCase {

  @Test
  public void test() {

    ResetBasicData.reset();

    EbeanServer server = Ebean.getServer(null);

    Query<Customer> query = server.find(Customer.class)
        .setAutoTune(false)
        //.fetch("contacts", new FetchConfig().query(2)).where().gt("id", 0).orderBy("id")
        .setMaxRows(2);

    final AtomicInteger count = new AtomicInteger();

    query.findEach(new QueryEachConsumer<Customer>() {
      @Override
      public void accept(Customer bean) {
        count.incrementAndGet();
      }
    });

    assertEquals(2, count.get());
  }

  @Test
  public void testWithLazyLoading() {

    ResetBasicData.reset();

    Ebean.find(Order.class)
            //.select("orderDate")
            .where().gt("id",0).le("id",10)
            .findEach(new QueryEachConsumer<Order>() {
              @Override
              public void accept(Order order) {
                Customer customer = order.getCustomer();
                // invoke lazy loading on customer, order details and order shipments
                order.getId();
                customer.getName();
                order.getDetails().size();
                order.getShipments().size();
              }
            });

  }

  @Test
  public void testWithLazyBatchSize() {

    ResetBasicData.reset();

    LoggedSqlCollector.start();

    Ebean.find(Order.class)
      .setLazyLoadBatchSize(10)
      .select("status, orderDate")
      .fetch("customer", "name")
      .where().gt("id",0).le("id",10)
      .setUseCache(false)
      .findEach(new QueryEachConsumer<Order>() {
        @Override
        public void accept(Order order) {
          Customer customer = order.getCustomer();
          customer.getName();
          order.getDetails().size();
          order.getShipments().size();
        }
      });


    List<String> loggedSql = LoggedSqlCollector.stop();

    assertEquals(3, loggedSql.size());
    assertTrue(loggedSql.get(0).contains("select t0.id c0, t0.status c1, t0.order_date c2, t1.id c3, t1.name c4 from o_order t0 join o_customer t1"));
    assertTrue(loggedSql.get(1).contains("select t0.order_id c0, t0.id c1, t0.order_qty c2, t0.ship_qty c3, t0.unit_price c4"));
    assertTrue(loggedSql.get(2).contains("select t0.order_id c0, t0.id c1, t0.ship_time c2, t0.cretime c3, t0.updtime c4, t0.version c5, t0.order_id c6 from or_order_ship"));
  }

  @Test
  public void testWithTwoJoins() {

    ResetBasicData.reset();

    LoggedSqlCollector.start();

    // make sure we don't hit the L2 cache for order shipments
    Ebean.getServerCacheManager().getBeanCache(Order.class).clear();
    Ebean.getServerCacheManager().getQueryCache(Order.class).clear();
    Ebean.getServerCacheManager().getBeanCache(OrderShipment.class).clear();
    Ebean.getServerCacheManager().getQueryCache(OrderShipment.class).clear();

    Ebean.find(Order.class)
          .setLazyLoadBatchSize(10)
          .setUseCache(false)
          .select("status, orderDate")
          .fetch("customer", "name")
          .fetch("details")
          .where().gt("id",0).le("id",10)
          .order().asc("id")
          .findEach(new QueryEachConsumer<Order>() {
            @Override
            public void accept(Order order) {
              Customer customer = order.getCustomer();
              order.getId();
              customer.getName();
              order.getDetails().size();
              order.getShipments().size();
            }
          });

    List<String> loggedSql = LoggedSqlCollector.stop();

    assertEquals("Got SQL: "+loggedSql, 2, loggedSql.size());
    assertThat(loggedSql.get(0)).contains("select t0.id c0, t0.status c1, t0.order_date c2, t1.id c3, t1.name c4, t2.id c5, t2.order_qty c6, t2.ship_qty");
    assertThat(loggedSql.get(1)).contains("select t0.order_id c0, t0.id c1, t0.ship_time c2, t0.cretime c3, t0.updtime c4, t0.version c5, t0.order_id c6 from or_order_ship");
  }

  @Test(expected=PersistenceException.class)
  public void testWithExceptionInQuery() {

    ResetBasicData.reset();

    EbeanServer server = Ebean.getServer(null);

    // intentionally a query with incorrect type binding
    Query<Customer> query = server.find(Customer.class)
        .setAutoTune(false)
        .where().gt("id","JUNK_NOT_A_LONG")
        .setMaxRows(2);

    // this throws an exception immediately
    query.findEach(new QueryEachConsumer<Customer>() {
      @Override
      public void accept(Customer bean) {

      }
    });

    if (!server.getName().equals("h2")) {
      // MySql allows the query with type conversion?
      throw new PersistenceException("H2 does expected thing but MySql does not");
    }
    assertTrue("Never get here as exception thrown", false);
  }
  
  
  @Test(expected=IllegalStateException.class)
  public void testWithExceptionInLoop() {

    ResetBasicData.reset();

    EbeanServer server = Ebean.getServer(null);

    Query<Customer> query = server.find(Customer.class)
        .setAutoTune(false)
        .where().gt("id", 0)
        .setMaxRows(2);

    query.findEach(new QueryEachConsumer<Customer>() {
      @Override
      public void accept(Customer customer) {
        if (customer != null) {
          throw new IllegalStateException("cause an exception");
        }
      }
    });
  }
}