package dataAccess;

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

import java.rmi.RemoteException;
import java.util.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.HouseFeatures;
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()) {
			openDB();
			System.out.println("DataBase opened");
		} else // c.isDatabaseLocal==false
		{
			openSDB();
			System.out.println("Remote DataBase opened");
		}
		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());
		configuration.common().objectClass(Owner.class).cascadeOnDelete(true);
		db = Db4oEmbedded.openFile(configuration, c.getDb4oFilename());
	}

	private void openSDB() {

		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("Ezkioko", "Ezkioko etxea", "Beatriz", 3, 3, 3, 3,
					3);
			jon.addRuralHouse("Eskiatze", "Eskiatzeko etxea", "Guazate", 4, 4, 4,
					4, 4);
			jon.setBankAccount("1349 5677 21 2133567777");
			alfredo.addRuralHouse("Aitonako", "Casa del abuelo", "Vegas", 5,
					5, 5, 5, 5);
			alfredo.addRuralHouse("Murgoitz", "", "Cedro", 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();
		}
	}

	public void deleteDB() {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		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();
		}
	}

	@SuppressWarnings("finally")
	public Offer createOffer(RuralHouse ruralHouse, Date firstDay,
			Date lastDay, float price) throws RemoteException, Exception {
		Offer o = null;

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {

			RuralHouse proto = new RuralHouse(ruralHouse.getHouseName(), 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 {
			db.close();
		}
		return o;
	}

	@SuppressWarnings("finally")
	public Offer modifyOffer(Offer offer) throws RemoteException, Exception {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {

			db.store(offer);
			db.commit();

		} catch (com.db4o.ext.ObjectNotStorableException e) {
			System.out
					.println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
		} finally {
			db.close();
		}
		return offer;
	}

	@SuppressWarnings("finally")
	public void deleteOffer(RuralHouse rh, Offer offer) throws RemoteException,
			Exception {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {

			db.store(rh);
			db.delete(offer);
			db.commit();

		} catch (com.db4o.ext.ObjectNotStorableException e) {
			System.out
					.println("Error: com.db4o.ext.ObjectNotStorableException in createOffer");
		} 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 {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		Booking bok = null;

		try {

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

			RuralHouse proto = new RuralHouse(ruralHouse.getHouseName(), null,
					ruralHouse.getDescription(), ruralHouse.getDistrict(), 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();
				bok = offer.getBooking();
			}

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

	/**
	 * This method existing owners
	 * 
	 */
	public Vector<Owner> getOwners() throws RemoteException, Exception {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		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)
			openSDB();
		else
			openDB();

		try {
			RuralHouse proto = new RuralHouse(null, 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 {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {

			RuralHouse rhn = (RuralHouse) db.queryByExample(
					new RuralHouse(rh.getHouseName(), 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 {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		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) {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		boolean stored = false;
		RuralHouse house = new RuralHouse(rh.getHouseName(), 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(RuralHouse rh, Owner owner) {

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();
		try {
			ObjectSet<RuralHouse> result = db.queryByExample(rh);
			if (!result.isEmpty()) {
				RuralHouse found = (RuralHouse) result.get(0);
				// db.delete(found.getOwner());
				db.store(owner);
				db.delete(found);
				db.commit();
			}
		} catch (Exception exc) {
			exc.printStackTrace();
		} finally {
			db.close();
		}

	}

	public Vector<RuralHouse> getRuralHousesByTown(String town) {
		RuralHouse rh = new RuralHouse(null, null, null, town, null);

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			ObjectSet<RuralHouse> result = db.queryByExample(rh);
			Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
			while (result.hasNext())
				ruralHouses.add(result.next());
			return ruralHouses;
		} finally {
			db.close();
		}

	}

	public RuralHouse getRuralHouseByName(String name) {
		RuralHouse rh = new RuralHouse(name, null, null, null, null);

		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			ObjectSet<RuralHouse> result = db.queryByExample(rh);
			Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
			while (result.hasNext())
				ruralHouses.add(result.next());
			db.close();
			if (!ruralHouses.isEmpty())
				return ruralHouses.get(0);
			else
				return null;
		} catch (NullPointerException e) {
			return null;
		}

	}

	public Vector<RuralHouse> getRuralHouses(String town, int nBed, int nKit,
			int nBath, int nPark, int nLiv) {
		HouseFeatures fea = new HouseFeatures(nBed, nKit, nBath, nLiv, nPark);
		RuralHouse rh = new RuralHouse(null, null, null, town, fea);
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			ObjectSet<RuralHouse> result = db.queryByExample(rh);
			Vector<RuralHouse> ruralHouses = new Vector<RuralHouse>();
			while (result.hasNext())
				ruralHouses.add(result.next());
			db.close();
			return ruralHouses;
		} catch (NullPointerException e) {
			return null;
		}

	}
}