package dataAccess;

import java.io.File;
//import java.util.Enumeration;
//import java.util.Vector;


import java.rmi.RemoteException;
import java.sql.Date;
import java.util.HashSet;
import java.util.ListIterator;
import java.util.Vector;

import com.db4o.*;
import com.db4o.config.EmbeddedConfiguration;
import com.db4o.cs.Db4oClientServer;
import com.db4o.cs.config.ClientConfiguration;

import configuration.ConfigXML;
import domain.Account;
import domain.Booking;
import domain.Offer;
//import dataModel.Offer;
import domain.Owner;
import domain.RuralHouse;
import exceptions.OfferCanNotBeBooked;
import exceptions.OverlappingOfferExists;
public class DB4oManager { 

	private static ObjectContainer  db;
	private static EmbeddedConfiguration configuration;
	private static ClientConfiguration configurationCS;
	private int bookingNumber=0; // if it is "static" then it is not serialized
	private int offerNumber=0;   // if it is "static" then it is not serialized
	private static DB4oManager theDB4oManager=null;

	private static DB4oManagerAux theDB4oManagerAux;
	static ConfigXML c;

	private DB4oManager() throws Exception {
		theDB4oManagerAux=new DB4oManagerAux(0,0);
		c=ConfigXML.getInstance();
		System.out.println("Creating DB4oManager instance => isDatabaseLocal: "+c.isDatabaseLocal()+" getDatabBaseOpenMode: "+c.getDataBaseOpenMode());

		
		if ((c.getDataBaseOpenMode().equals("initialize")) && (c.isDatabaseLocal()))
				new File(c.getDb4oFilename()).delete();
		
		if (c.isDatabaseLocal())
		{
			configuration = Db4oEmbedded.newConfiguration();
			configuration.common().activationDepth(c.getActivationDepth());
			configuration.common().updateDepth(c.getUpdateDepth());
			db=Db4oEmbedded.openFile(configuration, c.getDb4oFilename());
			System.out.println("DataBase opened");
		}
		else // c.isDatabaseLocal==false
		{ 
			openObjectContainer();
		}
		if (c.getDataBaseOpenMode().equals("initialize"))
		{	initializeDB();
			System.out.println("DataBase initialized");
		}
		else // c.getDataBaseOpenMode().equals("open")
		
			{	
				ObjectSet res =db.queryByExample(DB4oManagerAux.class);
				ListIterator listIter = res.listIterator();
				if (listIter.hasNext()) theDB4oManagerAux = (DB4oManagerAux) res.next();         	
            }
		}

	private static void openDB(){
		configuration = Db4oEmbedded.newConfiguration();
		configuration.common().activationDepth(c.getActivationDepth());
		configuration.common().updateDepth(c.getUpdateDepth());
		db=Db4oEmbedded.openFile(configuration, c.getDb4oFilename());
	}
		
	private void openObjectContainer(){
		
		configurationCS = Db4oClientServer.newClientConfiguration();
		configurationCS.common().activationDepth(c.getActivationDepth());
		configurationCS.common().updateDepth(c.getUpdateDepth());
		configurationCS.common().objectClass(Owner.class).cascadeOnDelete(true);
		db = Db4oClientServer.openClient(configurationCS,c.getDatabaseNode(), 
				 c.getDatabasePort(),c.getUser(),c.getPassword());

	}
	
	class DB4oManagerAux {
		int bookingNumber;
		int offerNumber;
		DB4oManagerAux(int bookingNumber,int offerNumber){
			this.bookingNumber=bookingNumber;
			this.offerNumber=offerNumber;
		}
	}

	public static DB4oManager getInstance() throws Exception{
		if (theDB4oManager==null)
			theDB4oManager=new DB4oManager();
		return theDB4oManager;
	}
	
	
	public void initializeDB(){
		
		try {
			Owner jon = new Owner("Jon");
			Owner alfredo = new Owner("Alfredo");
			jon.addRuralHouse(1, "Ezkioko etxea", "Ezkio", 3, 3, 3, 3, 3);
			jon.addRuralHouse(2, "Eskiatzeko etxea", "Jaca", 4, 4, 4, 4, 4);
			jon.setBankAccount("1349 5677 21 2133567777");
			alfredo.addRuralHouse(3, "Casa del abuelo", "Pitillas", 5, 5,
					5, 5, 5);
			alfredo.addRuralHouse(4,"", "Murgia", 6, 6, 6, 6, 6);
			alfredo.setBankAccount("4144 0087 23 9700002133");
			Account jonAcc = new Account("userJon", "passJon", jon);
			Account alfredoAcc = new Account("userAlfredo", "passAlfredo",
					alfredo);
			db.store(jon);
			db.store(alfredo);
			db.store(jonAcc);
			db.store(alfredoAcc);
			db.commit();
		}
		finally {
			//db.close();
		}
	}
	
	@SuppressWarnings("finally")
	public Offer createOffer(RuralHouse ruralHouse, Date firstDay, Date lastDay,
			float price) throws RemoteException, Exception {
	Offer o = null;
	try {
		
		if (c.isDatabaseLocal()==false) openObjectContainer();
		
		
		RuralHouse proto = new RuralHouse(ruralHouse.getHouseNumber(),null,null,null,null);
		ObjectSet result = db.queryByExample(proto);
		RuralHouse rh=(RuralHouse)result.next();
		o=rh.createOffer(theDB4oManagerAux.offerNumber++,firstDay, lastDay, price);
		db.store(theDB4oManagerAux); // To store the new value for offerNumber
		db.store(o);
		db.commit(); 
		
	}
	catch (com.db4o.ext.ObjectNotStorableException e){
		System.out.println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
	}
	finally {
		return o;
	}
	}
	
	public void deleteDB() {
		
		try {
			 Owner proto = new Owner(null,null);
			 ObjectSet result = db.queryByExample(proto);
			 Vector<Owner> owners=new Vector<Owner>();
			 while(result.hasNext())
			 { 	Owner o = (Owner)result.next();
			 	System.out.println("Deleted owner: "+o.toString());
			 	db.delete(o);
			 }
			 db.commit();
	     } finally {
	        // db.close();
	     }
	}

	/**
	 * This method creates a book with a corresponding parameters
	 * 
	 * @param First
	 *            day, last day, house number and telephone
	 * @return a book
	 */
	public Booking createBooking(RuralHouse ruralHouse, Date firstDate, Date lastDate, String bookTelephoneNumber)
			throws OfferCanNotBeBooked {
		
		try {

			if (c.isDatabaseLocal()==false) openObjectContainer();

			RuralHouse proto = new RuralHouse(ruralHouse.getHouseNumber(),null,ruralHouse.getDescription(),ruralHouse.getTown(), null);
			 ObjectSet result = db.queryByExample(proto);
			 RuralHouse rh=(RuralHouse)result.next();

			Offer offer;
			offer = rh.findOffer(firstDate, lastDate);

			if (offer!=null) {
				offer.createBooking(theDB4oManagerAux.bookingNumber++, bookTelephoneNumber);
				db.store(theDB4oManagerAux); // To store the new value for bookingNumber
				db.store(offer);
				db.commit();
				return offer.getBooking();
			}
			return null;

		} catch (com.db4o.ext.ObjectNotStorableException e){
				System.out.println("Error: com.db4o.ext.ObjectNotStorableException in createBooking");
				return null;
			}
		catch (Exception exc) {
			exc.printStackTrace();
			return null;
		}
	}


	/**
	 * This method existing  owners 
	 * 
	 */
	public Vector<Owner> getOwners() throws RemoteException,
			Exception {
		
		if (c.isDatabaseLocal()==false) openObjectContainer();

		 try {
			 Owner proto = new Owner(null,null);
			 ObjectSet result = db.queryByExample(proto);
			 Vector<Owner> owners=new Vector<Owner>();
			 while(result.hasNext())				 
				 owners.add((Owner)result.next());
			 return owners;
	     } finally {
	         //db.close();
	     }
	} 
	public Vector<RuralHouse> getAllRuralHouses() throws RemoteException,
	Exception {
		if (c.isDatabaseLocal()==false) openObjectContainer();

		 try {
			 RuralHouse proto = new RuralHouse(0,null,null,null,null);
			 ObjectSet result = db.queryByExample(proto);
			 Vector<RuralHouse> ruralHouses=new Vector<RuralHouse>();
			 while(result.hasNext()) 
				 ruralHouses.add((RuralHouse)result.next());
			 return ruralHouses;
	     } finally {
	        // db.close();
	     }
	}
	
	public boolean existsOverlappingOffer(RuralHouse rh,Date firstDay, Date lastDay) throws RemoteException, OverlappingOfferExists{
		 try {
			if (c.isDatabaseLocal()==false) openObjectContainer();

			RuralHouse rhn = (RuralHouse) db.queryByExample(new RuralHouse(rh.getHouseNumber(),null,null,null,null)).next();		
			if (rhn.overlapsWith(firstDay, lastDay)!=null) throw new OverlappingOfferExists();
			else return false; 
	     } finally {
	         //db.close();
	     }
	}

	public static ObjectContainer getContainer(){
		return db;
	}
	
	public void close(){
		db.close();
		System.out.println("DataBase closed");
	}
	
	public String toString() {
		return "bookingNumber="+bookingNumber+" offerNumber="+offerNumber;
	}



	/**
	 * @param usr
	 * @param pwd
	 * @return
	 * @throws RemoteException
	 * @throws Exception
	 */
	public Vector<Account> getAccount(String usr, String pwd)
			throws RemoteException, Exception {

		try {
			Account proto = new Account(usr, pwd, new Owner(null, null));
			ObjectSet<Account> result = db.queryByExample(proto);
			Vector<Account> accounts = new Vector<Account>();
			while (result.hasNext())
				accounts.add((Account) result.next());
			return accounts;
		} finally {
			//db.close();
		}
	}

	/**
	 * @param rh
	 */
	public boolean storeRuralHouses(RuralHouse rh) {
		DB4oManager.openDB();
		boolean stored = false;
		ObjectContainer db = DB4oManager.getContainer();
		RuralHouse house = new RuralHouse(rh.getHouseNumber(), null, null,
				null, null);
		try {
			ObjectSet<Owner> result = db.queryByExample(house);
			if (result.isEmpty()) {
				db.store(rh);
				db.commit();
				stored = true;
			}
		} finally {
			db.close();
		}
		return stored;
	}

	public void removeHouse(int houseNumber) {
		DB4oManager.openDB();
		RuralHouse house = new RuralHouse(houseNumber, null, null, null, null);
		try {
			ObjectSet<RuralHouse> result = db.queryByExample(house);
			if (!result.isEmpty()) {
				RuralHouse found = (RuralHouse) result.get(0);
				db.delete(found);
				db.commit();
			}
		} catch (Exception exc) {
			exc.printStackTrace();
		} finally {
			db.close();
		}

	}
}