/**
 * Copyright (c) 2004 - 2009 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Eike Stepper - initial API and implementation
 *    Martin Taal - extended testcase
 */
package org.eclipse.emf.cdo.tests.hibernate;

import org.eclipse.emf.cdo.net4j.CDONet4jUtil;
import org.eclipse.emf.cdo.net4j.CDOSessionConfiguration;
import org.eclipse.emf.cdo.session.CDOSession;
import org.eclipse.emf.cdo.tests.model1.Category;
import org.eclipse.emf.cdo.tests.model1.Customer;
import org.eclipse.emf.cdo.tests.model1.Model1Factory;
import org.eclipse.emf.cdo.tests.model1.Model1Package;
import org.eclipse.emf.cdo.tests.model1.Order;
import org.eclipse.emf.cdo.tests.model1.OrderDetail;
import org.eclipse.emf.cdo.tests.model1.Product1;
import org.eclipse.emf.cdo.tests.model1.PurchaseOrder;
import org.eclipse.emf.cdo.tests.model1.SalesOrder;
import org.eclipse.emf.cdo.tests.model1.Supplier;
import org.eclipse.emf.cdo.transaction.CDOTransaction;

import org.eclipse.net4j.Net4jUtil;
import org.eclipse.net4j.connector.IConnector;
import org.eclipse.net4j.tcp.TCPUtil;
import org.eclipse.net4j.util.container.ContainerUtil;
import org.eclipse.net4j.util.container.IManagedContainer;
import org.eclipse.net4j.util.io.IOUtil;
import org.eclipse.net4j.util.om.OMPlatform;
import org.eclipse.net4j.util.om.log.PrintLogHandler;
import org.eclipse.net4j.util.om.trace.PrintTraceHandler;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import junit.framework.TestCase;

/**
 * @author Eike Stepper
 */
public class HibernateTest extends TestCase
{
  private static final String REPOSITORY_NAME = "repo1";

  private static final int NO_OF_BUSINESS_PARTNERS = 3;

  private static final int NO_OF_PRODUCTS = 7;

  private static final int NO_OF_ORDERS = 11;

  private static final long BASE_MILLIS = new Date().getTime();

  private static final boolean TRACE_TO_CONSOLE = true;

  private static final boolean TRACE_TO_FILE = false;

  private static PrintStream traceStream;

  public void testHibernate() throws Exception
  {
    try
    {
      IManagedContainer container = initContainer();
      IConnector connector = TCPUtil.getConnector(container, "localhost:2036"); // Open a TCP connection

      CDOSession session = openSession(connector);
      session.getPackageRegistry().putEPackage(Model1Package.eINSTANCE);

      CDOTransaction transaction = session.openTransaction();
      Resource resource = transaction.createResource("/my/big/resource");
      resource.getContents().add(getInputModel());

      // note that specific setters are not always called because of bi-directional
      // relations, so adding an orderdetail to an order.getOrderDetails list will
      // set the order feature of the orderdetail
      final Category productCategory = createCategory("SalesPurchase");
      final List<Customer> customers = new ArrayList<Customer>();
      final List<Supplier> suppliers = new ArrayList<Supplier>();
      final List<Order> orders = new ArrayList<Order>();
      for (int j = 0; j < NO_OF_BUSINESS_PARTNERS; j++)
      {
        final Customer customer = createCustomer(j);
        customers.add(customer);
        for (int i = 0; i < NO_OF_ORDERS; i++)
        {
          customer.getSalesOrders().add(createSalesOrder(j * 1000 + i, customer, productCategory.getProducts()));
        }

        orders.addAll(customer.getSalesOrders());

        final Supplier supplier = createSupplier(j);
        suppliers.add(supplier);
        for (int i = 0; i < NO_OF_ORDERS; i++)
        {
          supplier.getPurchaseOrders().add(createPurchaseOrder(j * 1000 + i, supplier, productCategory.getProducts()));
        }

        orders.addAll(supplier.getPurchaseOrders());
      }

      resource.getContents().add(productCategory);
      resource.getContents().addAll(customers);
      resource.getContents().addAll(suppliers);
      resource.getContents().addAll(orders);

      transaction.commit();
      session.close();

      CDOSession session2 = openSession(connector);
      CDOTransaction transaction2 = session2.openTransaction();
      Resource resource2 = transaction2.getResource("/my/big/resource");
      Category category = (Category)resource2.getContents().get(0);
      assertEquals("CAT1", category.getName());
      assertEquals("CAT2", category.getCategories().get(0).getName());
      assertEquals("P1", category.getProducts().get(0).getName());
      assertEquals("P2", category.getProducts().get(1).getName());
      assertEquals("P3", category.getCategories().get(0).getProducts().get(0).getName());
      assertEquals(category, category.getProducts().get(1).eContainer());

      checkTestData(resource2);

      transaction.close();

      // Cleanup
      session2.close();
      connector.close();
    }
    finally
    {
      IOUtil.close(traceStream);
    }
  }

  protected static CDOSession openSession(IConnector connector)
  {
    CDOSessionConfiguration configuration = CDONet4jUtil.createSessionConfiguration();
    configuration.setConnector(connector);
    configuration.setRepositoryName(REPOSITORY_NAME);
    return configuration.openSession();
  }

  protected static Model1Factory getModel1Factory()
  {
    return Model1Factory.eINSTANCE;
  }

  private static IManagedContainer initContainer() throws FileNotFoundException
  {
    // Turn on tracing
    OMPlatform.INSTANCE.setDebugging(false);
    OMPlatform.INSTANCE.addLogHandler(PrintLogHandler.CONSOLE);
    if (TRACE_TO_FILE)
    {
      traceStream = new PrintStream("trace.txt");
      OMPlatform.INSTANCE.addTraceHandler(new PrintTraceHandler(traceStream));
    }

    if (TRACE_TO_CONSOLE)
    {
      OMPlatform.INSTANCE.addTraceHandler(PrintTraceHandler.CONSOLE);
    }

    // Prepare the standalone infra structure (not needed when running inside Eclipse)
    IManagedContainer container = ContainerUtil.createContainer(); // Create a wiring container
    Net4jUtil.prepareContainer(container); // Prepare the Net4j kernel
    TCPUtil.prepareContainer(container); // Prepare the JVM transport
    CDONet4jUtil.prepareContainer(container); // Prepare the CDO client
    container.activate();
    return container;
  }

  private static EObject getInputModel()
  {
    Category cat1 = getModel1Factory().createCategory();
    cat1.setName("CAT1");
    Category cat2 = getModel1Factory().createCategory();
    cat2.setName("CAT2");
    cat1.getCategories().add(cat2);
    Product1 p1 = getModel1Factory().createProduct1();
    p1.setName("P1");
    cat1.getProducts().add(p1);
    Product1 p2 = getModel1Factory().createProduct1();
    p2.setName("P2");
    cat1.getProducts().add(p2);
    Product1 p3 = getModel1Factory().createProduct1();
    p3.setName("P3");
    cat2.getProducts().add(p3);
    return cat1;
  }

  private void checkTestData(Resource res)
  {
    final Category productCategory = (Category)res.getContents().get(1);

    int startIndex = 2;
    int customerIndex = 0;
    int numOfBPs = 0;
    int numOfOrders = 0;
    for (int i = startIndex; i < startIndex + NO_OF_BUSINESS_PARTNERS; i++)
    {
      final Customer c = (Customer)res.getContents().get(i);
      assertEquals(NO_OF_ORDERS, c.getSalesOrders().size());
      assertEquals("Amsterdam" + customerIndex, c.getCity());
      assertEquals("Customer" + customerIndex, c.getName());
      assertEquals("Leidseplein" + customerIndex, c.getStreet());
      int orderIndex = 0;
      for (SalesOrder so : c.getSalesOrders())
      {
        assertEquals(NO_OF_PRODUCTS, so.getOrderDetails().size());
        assertEquals(customerIndex * 1000 + orderIndex, so.getId());
        float price = 1.0f;
        int detailIndex = 0;
        for (OrderDetail od : so.getOrderDetails())
        {
          assertTrue(productCategory.getProducts().contains(od.getProduct()));
          assertEquals(so, od.getOrder());
          assertEquals(so, od.eContainer());
          assertEquals(price, od.getPrice(), 0.0001f);
          assertEquals("SalesPurchaseProduct" + detailIndex, od.getProduct().getName());
          assertTrue(od.getProduct().getOrderDetails().contains(od));
          price += 1.0f;
          detailIndex++;
        }

        assertTrue(res.getContents().contains(so));
        orderIndex++;
        numOfOrders++;
      }

      customerIndex++;
      numOfBPs++;
    }

    startIndex = 2 + NO_OF_BUSINESS_PARTNERS;
    int supplierIndex = 0;
    for (int i = startIndex; i < startIndex + NO_OF_BUSINESS_PARTNERS; i++)
    {
      Supplier s = (Supplier)res.getContents().get(i);
      assertEquals("Berlin" + supplierIndex, s.getCity());
      assertEquals("Supplier" + supplierIndex, s.getName());
      assertEquals("Potsdamer Platz" + supplierIndex, s.getStreet());

      int orderIndex = 0;
      for (PurchaseOrder po : s.getPurchaseOrders())
      {
        assertEquals(BASE_MILLIS + supplierIndex * 1000 + orderIndex, po.getDate().getTime());

        float price = 1000.0f;
        int detailIndex = 0;
        for (OrderDetail od : po.getOrderDetails())
        {
          assertTrue(productCategory.getProducts().contains(od.getProduct()));
          assertEquals(po, od.getOrder());
          assertEquals(po, od.eContainer());
          assertEquals(price, od.getPrice(), 0.0001f);
          assertEquals("SalesPurchaseProduct" + detailIndex, od.getProduct().getName());
          assertTrue(od.getProduct().getOrderDetails().contains(od));
          price += 1.0f;
          detailIndex++;
        }

        orderIndex++;
        numOfOrders++;
      }

      numOfBPs++;
      supplierIndex++;
    }

    // 2 is for the categories
    assertEquals(2 + numOfBPs + numOfOrders, res.getContents().size());
  }

  private static Category createCategory(String prefix)
  {
    Category catalog = getModel1Factory().createCategory();
    catalog.setName(prefix + "Catalog");
    for (int i = 0; i < NO_OF_PRODUCTS; i++)
    {
      Product1 p = getModel1Factory().createProduct1();
      p.setName(prefix + "Product" + i);
      catalog.getProducts().add(p);
    }

    return catalog;
  }

  private static Customer createCustomer(int index)
  {
    final Customer c = getModel1Factory().createCustomer();
    c.setCity("Amsterdam" + index);
    c.setName("Customer" + index);
    c.setStreet("Leidseplein" + index);
    return c;
  }

  private static Supplier createSupplier(int index)
  {
    final Supplier s = getModel1Factory().createSupplier();
    s.setName("Supplier" + index);
    s.setCity("Berlin" + index);
    s.setStreet("Potsdamer Platz" + index);
    return s;
  }

  private static SalesOrder createSalesOrder(int index, Customer c, List<Product1> products)
  {
    final SalesOrder so = getModel1Factory().createSalesOrder();
    so.setId(index);
    so.getOrderDetails().addAll(createOrderDetails(products, 1.0f));
    return so;
  }

  private static PurchaseOrder createPurchaseOrder(int index, Supplier supplier, List<Product1> products)
  {
    final PurchaseOrder po = getModel1Factory().createPurchaseOrder();
    po.setDate(new Date(BASE_MILLIS + index));
    po.getOrderDetails().addAll(createOrderDetails(products, 1000.0f));
    return po;
  }

  private static List<OrderDetail> createOrderDetails(List<Product1> products, float basePrice)
  {
    final List<OrderDetail> ods = new ArrayList<OrderDetail>();
    float price = basePrice;
    for (Product1 p : products)
    {
      ods.add(createOrderDetail(p, price));
      price += 1f;
    }

    return ods;
  }

  private static OrderDetail createOrderDetail(Product1 product, float price)
  {
    final OrderDetail od = getModel1Factory().createOrderDetail();
    od.setPrice(price);
    od.setProduct(product);
    return od;
  }
}