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.List;
import java.util.ListIterator;
import java.util.Vector;

import com.db4o.Db4oEmbedded;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.config.EmbeddedConfiguration;
import com.db4o.cs.Db4oClientServer;
import com.db4o.cs.config.ClientConfiguration;
import com.db4o.query.Predicate;

import configuration.ConfigXML;
import domain.Account;
import domain.Administrator;
import domain.Booking;
import domain.Client;
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<DB4oManagerAux> res = db
					.queryByExample(DB4oManagerAux.class);
			ListIterator<DB4oManagerAux> 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).cascadeOnUpdate(true);
		configuration.common().objectClass(Owner.class).cascadeOnDelete(true);
		configuration.common().objectClass(RuralHouse.class)
				.cascadeOnUpdate(true);
		configuration.common().objectClass(Account.class).cascadeOnUpdate(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", "1349 5677 21 2133567777",
					"Jon@gmail.com");
			Owner alfredo = new Owner("Alfredo", "4144 0087 23 9700002133",
					"alfredo@gmail.com");
			jon.addRuralHouse("Ezkioko", "Ezkioko etxea", "Beatriz", 3, 3, 3,
					3, 3);
			jon.addRuralHouse("Eskiatze", "Eskiatzeko etxea", "Guazate", 4, 4,
					4, 4, 4);
			alfredo.addRuralHouse("Aitonako", "Casa del abuelo", "Vegas", 5, 5,
					5, 5, 5);

			alfredo.addRuralHouse("Murgoitz", "", "Cedro", 6, 6, 6, 6, 6);
			Account jonAcc = new Account("1", "1", jon);
			Account alfredoAcc = new Account("userAlfredo", "passAlfredo",
					alfredo);

			Account admin = new Account("admin", "admin", true);
			db.store(Administrator.getInstance());
			db.store(jonAcc);
			db.store(alfredoAcc);
			db.store(admin);
			db.commit();
		} finally {
			db.close();
		}
	}

	public void deleteDB() {

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

		try {
			Owner proto = new Owner(null, null, null);
			ObjectSet<Owner> result = db.queryByExample(proto);
			while (result.hasNext()) {
				Owner o = (Owner) result.next();
				System.out.println("Deleted owner: " + o.toString());
				db.delete(o);
			}
			db.commit();
		} finally {
			db.close();
		}
	}

	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<RuralHouse> 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;
	}

	public void deleteOffer(Offer offer) throws RemoteException, Exception {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			ObjectSet<Offer> of = db.queryByExample(offer);
			RuralHouse rh = of.get(0).getRuralHouse();
			System.out.println(rh.offers.remove(of.get(0)));
			db.store(rh);
			db.commit();

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

	public Administrator getAdminData() {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {

			List<Administrator> admL = db.query(new Predicate<Administrator>() {
				/**
				 * 
				 */
				private static final long serialVersionUID = 1L;

				public boolean match(Administrator admin) {
					return true;
				}
			});

			return admL.get(0);
		} finally {
			db.close();

		}

	}

	public void storeAdmin() {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();
		try {

			List<Administrator> admL = db.query(new Predicate<Administrator>() {
				/**
				 * 
				 */
				private static final long serialVersionUID = 1L;

				public boolean match(Administrator admin) {
					return true;
				}
			});

			admL.get(0).setAddRequest(
					Administrator.getInstance().getAddRequest());
			admL.get(0).setRemoveRequest(
					Administrator.getInstance().getRemoveRequest());
			admL.get(0).setNewOwnerRequest(
					Administrator.getInstance().getNewOwnerRequest());
			db.commit();

		} catch (Exception e) {

		} 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 Vector<Booking> createBooking(RuralHouse ruralHouse, Date firstDate,
			Date lastDate, Client cl) throws OfferCanNotBeBooked {

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

		Vector<Booking> book = new Vector<Booking>() ;

		try {

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

			RuralHouse proto = new RuralHouse(ruralHouse.getHouseName(), null,
					ruralHouse.getDescription(), ruralHouse.getDistrict(), null);
			ObjectSet<RuralHouse> result = db.queryByExample(proto);
			RuralHouse rh = (RuralHouse) result.next();

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

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

		} 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 book;
	}

	/**
	 * 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, null);
			ObjectSet<Owner> 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<RuralHouse> 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 ps
	 * @return
	 * @throws RemoteException
	 * @throws Exception
	 */
	public Vector<Account> getAccount(Account proto) throws RemoteException,
			Exception {

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

		try {
			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<RuralHouse> result = db.queryByExample(house);
			if (result.isEmpty()) {
				Owner ow = (Owner) db.queryByExample(rh.getOwner()).get(0);
				rh.setOwner(ow);
				ow.addRuralHouse(rh);
				db.store(rh);
				db.commit();
				stored = true;
			} else {
				db.delete(result.get(0));
				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<Owner> result = db.queryByExample(owner);
			ObjectSet<RuralHouse> rhs = db.queryByExample(rh);
			if (!rhs.isEmpty()) {
				Owner found = result.get(0);
				found.getRuralHouses().remove(rhs.get(0));
				db.delete(rhs.get(0));
				db.store(found);
				db.commit();
			}
		} catch (Exception exc) {
			exc.printStackTrace();
		} finally {
			db.close();
		}

	}

	public Vector<RuralHouse> getRuralHouses(String name, 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(name, 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;
		}

	}

	public boolean addAccount(Account acc) {
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			// TODO realize if there is another account with same username.
			// Quite difficult with the f***ing salt
			db.store(acc);
			db.commit();
		} catch (Exception exc) {
			exc.printStackTrace();
		} finally {
			db.close();
		}
		return true;
	}

	// TODO remove account

	public boolean removeAccount(Account acc) {
		return false;
	}
	
	//TODO this method should be improved.
	public void acceptBooking(Offer of){
		Offer off = new Offer(of.getOfferNumber(),of.getRuralHouse(),of.getFirstDay(),of.getLastDay(),of.getPrice());
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();

		try {
			ObjectSet<Offer> result = db.queryByExample(off);
			this.deleteOffer(result.get(0));
			db.store(of);
			db.close();
			
		} catch (Exception e) {
			e.printStackTrace();;
		}		
	}
	
	public void removeBooking(Booking b){
		if (c.isDatabaseLocal() == false)
			openSDB();
		else
			openDB();
		try {
			ObjectSet<Booking> result = db.queryByExample(b);
			ObjectSet<Client> result2= db.queryByExample(b.getClient());
			db.delete(result.get(0));
			db.delete(result2.get(0));
			db.commit();
		} catch (Exception e) {
			e.printStackTrace();;
		}finally{
			db.close();
		}

		
	}
}