package dk.daoas.adressevedligehold;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;

import dk.daoas.adressevedligehold.AddressSourceEntry.EntryType;
import dk.daoas.adressevedligehold.beans.Address;
import dk.daoas.adressevedligehold.beans.Address.AddressState;
import dk.daoas.adressevedligehold.db.DatabaseLayerImplementation;
import dk.daoas.adressevedligehold.util.DeduplicateHelper;
import dk.daoas.adressevedligehold.util.TimingHelper;

public class AddressManager {
	
	
	List<Address> addressList;
	
	Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
	
	ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>(); 
	
	public AddressManager() throws SQLException {
		DatabaseLayerImplementation db = new DatabaseLayerImplementation();
		
		searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
		
		addressList = db.getAllAdresses();

		DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
		DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();

		List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>(); 
		
		TimingHelper timer = new TimingHelper();
		
		for (Address a : addressList) {
			Integer gadeid = intHelper.getInstance( a.gadeid );
			Short husnr = shortHelper.getInstance( a.husnr );
			TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
			
			if (gade == null) {
				gade = new TreeMap<Short,ArrayList<Address>>();
				searchStructure.put(gadeid, gade);
			}
			
			ArrayList<Address> litraList = gade.get(husnr);
			if (litraList == null) {
				litraList = new ArrayList<Address>();
				gade.put(husnr, litraList);
				arraylistCache.add(litraList);
			}
			
			litraList.add(a);
		}
		
		for (ArrayList<Address> list : arraylistCache) {
			list.trimToSize();
		}
		
		System.out.println("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
		
		
	}
	
	public void closeUnvisitedAddresses(String distributor, EntryUgedage ugedage) {
		for (Address addr : addressList) {
			if (addr.distributor == null)
				continue;
			
			if (addr.distributor.equals(distributor) == false)//irrelevant for denne indlæsning
				continue;
			
			int closedCount = 0;
			
			if (addr.visitedMan == false && ugedage.mandag) {
				if (addr.ruteMandag != null)  {
					addr.ruteMandag = null;
					addr.korelisteMandag = null;
					addr.stateMan = AddressState.CLOSED;
					closedCount++;
				}
			}
			if (addr.visitedTir == false && ugedage.tirsdag) {
				if (addr.ruteTirsdag != null)  {
					addr.ruteTirsdag = null;
					addr.korelisteTirsdag = null;
					addr.stateTir = AddressState.CLOSED;
					closedCount++;
				}
			}

			if (addr.visitedOns == false && ugedage.onsdag) {
				if (addr.ruteOnsdag != null)  {
					addr.ruteOnsdag = null;
					addr.korelisteOnsdag = null;
					addr.stateOns = AddressState.CLOSED;
					closedCount++;
				}
			}

			if (addr.visitedTor == false && ugedage.torsdag) {
				if (addr.ruteTorsdag != null)  {
					addr.ruteTorsdag = null;
					addr.korelisteTorsdag = null;
					addr.stateTor = AddressState.CLOSED;
					closedCount++;
				}
			}

			if (addr.visitedFre == false && ugedage.fredag) {
				if (addr.ruteFredag != null)  {
					addr.ruteFredag = null;
					addr.korelisteFredag = null;
					addr.stateFre = AddressState.CLOSED;
					closedCount++;
				}
			}

			if (addr.visitedLor == false && ugedage.lordag) {
				if (addr.ruteLordag != null)  {
					addr.ruteLordag = null;
					addr.korelisteLordag = null;
					addr.stateLor = AddressState.CLOSED;
					closedCount++;
				}
			}

			if (addr.visitedSon == false && ugedage.sondag) {
				if (addr.ruteSondag != null)  {
					addr.ruteSondag = null;
					addr.korelisteSondag = null;
					addr.stateSon = AddressState.CLOSED;
					closedCount++;
				}
			}
			
			if (addr.state == AddressState.NOT_CHANGED && closedCount>0) {
				addr.state = AddressState.CLOSED;
			}
		
		}
	}
	public void dumpChanged() {
		int count = 0;
		for (Address addr : addressList) {
			if (addr.state == AddressState.NOT_CHANGED) {
				continue;
			}
			if (addr.stateMan == AddressState.NOT_CHANGED || addr.stateMan == AddressState.CREATED) {
				continue;
			}
			
			if (addr.stateMan != AddressState.MODIFIED ) {
				continue;
			}
			
			System.out.println(addr.state + ": " + addr.toStringExtended() );
			System.out.println(addr.getRuteString() );
			
			if (count++ > 15)
				return;
		}
	}
	
	public void writeBackChanges() {
		System.out.println("Writing back changes");
		TimingHelper timer = new TimingHelper();
		
		List<Address> updates = new ArrayList<Address>(1024*1024);
		List<Address> inserts = new ArrayList<Address>(16*1024);
		
		for (Address addr : addressList) {
			if (addr.state == AddressState.CREATED) {
				inserts.add(addr);
			}
			if (addr.state == AddressState.MODIFIED || addr.state == AddressState.OPENED || addr.state == AddressState.CLOSED) {
				updates.add(addr);
			}
		}
		
		DatabaseLayerImplementation db = new DatabaseLayerImplementation();
		db.updateAddresses(updates);
		
		System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
	}
	
	
	public void visit(AddressSourceEntry entry) {
		if (entry.type == EntryType.TypeSingleAddress) {
			visitSingle(entry);
		} else {
			visitRange(entry);
		}
	}
	
	private void visitSingle(AddressSourceEntry entry) {
		TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
		if (gade == null) {
			createFromEntry(entry); // if we get here there was no match - so we need to create it
			return;
		}
		
		ArrayList<Address> litraList = gade.get(entry.husnr);
		if (litraList == null) {
			createFromEntry(entry); // if we get here there was no match - so we need to create it
			return;
		}
		
		for (Address addr : litraList) {
			if (addr.husnrbogstav.equals(entry.litra) ) {
				updateAddress(addr, entry);
				return; //Done for now - no need to look at the rest of the list
			}
		}
		
		createFromEntry(entry); // if we get here there was no match - so we need to create it
	}
	
	private void visitRange(AddressSourceEntry entry) {
		
		throw new UnsupportedOperationException("Not implemented yet");
	}
	
	
	
	private void updateAddress(Address addr, AddressSourceEntry entry) {
		if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
			afvisteEntries.add(entry);
			System.out.println("Afviser " + entry);
			return;
		}
		
		addr.visited = true;
		if (addr.state == AddressState.NOT_CHANGED) {
			if (addr.distributor == null) {
				addr.state = AddressState.OPENED;
				addr.distributor = entry.distributor;
			} else {
				addr.state = AddressState.MODIFIED;
			}
		}
		
		if (entry.ugedage.mandag) {
			addr.visitedMan = true;
			if (addr.ruteMandag == null) {
				addr.stateMan = AddressState.OPENED;
				addr.ruteMandag = entry.rute;
				addr.korelisteMandag = entry.koreliste;
			} else {
				
				if (StringUtils.equals(addr.ruteMandag, entry.rute) == false || StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
					addr.stateMan = AddressState.MODIFIED;
					addr.ruteMandag = entry.rute;
					addr.korelisteMandag = entry.koreliste;					
				}
			}
		}
		
		
		if (entry.ugedage.tirsdag) {
			addr.visitedTir = true;
			if (addr.ruteTirsdag == null) {
				addr.stateTir = AddressState.OPENED;
				addr.ruteTirsdag = entry.rute;
				addr.korelisteTirsdag = entry.koreliste;
			} else {
				
				if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
					addr.stateTir = AddressState.MODIFIED;
					addr.ruteTirsdag = entry.rute;
					addr.korelisteTirsdag = entry.koreliste;					
				}
			}
		}

		if (entry.ugedage.onsdag) {
			addr.visitedOns = true;
			if (addr.ruteOnsdag == null) {
				addr.stateOns = AddressState.OPENED;
				addr.ruteOnsdag = entry.rute;
				addr.korelisteOnsdag = entry.koreliste;
			} else {
				
				if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false || StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
					addr.stateOns = AddressState.MODIFIED;
					addr.ruteOnsdag = entry.rute;
					addr.korelisteOnsdag = entry.koreliste;					
				}
			}
		}

		
		if (entry.ugedage.torsdag) {
			addr.visitedTor = true;
			if (addr.ruteTorsdag == null) {
				addr.stateTor = AddressState.OPENED;
				addr.ruteTorsdag = entry.rute;
				addr.korelisteTorsdag = entry.koreliste;
			} else {
				
				
				if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
					addr.stateTor = AddressState.MODIFIED;
					addr.ruteTorsdag = entry.rute;
					addr.korelisteTorsdag = entry.koreliste;					
				}
			}
		}

		
		if (entry.ugedage.fredag) {
			addr.visitedFre = true;
			if (addr.ruteFredag == null) {
				addr.stateFre = AddressState.OPENED;
				addr.ruteFredag = entry.rute;
				addr.korelisteFredag = entry.koreliste;
			} else {
				
				if (StringUtils.equals(addr.ruteFredag, entry.rute) == false || StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
					addr.stateFre = AddressState.MODIFIED;
					addr.ruteFredag = entry.rute;
					addr.korelisteFredag = entry.koreliste;					
				}
			}
		}

		
		if (entry.ugedage.lordag) {
			addr.visitedLor = true;
			if (addr.ruteLordag == null) {
				addr.stateLor = AddressState.OPENED;
				addr.ruteLordag = entry.rute;
				addr.korelisteLordag = entry.koreliste;
			} else {
				
				
				if (StringUtils.equals(addr.ruteLordag, entry.rute) == false || StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
					addr.stateLor = AddressState.MODIFIED;
					addr.ruteLordag = entry.rute;
					addr.korelisteLordag = entry.koreliste;					
				}
			}
		}

		
		if (entry.ugedage.sondag) {
			addr.visitedSon = true;
			if (addr.ruteSondag == null) {
				addr.stateSon = AddressState.OPENED;
				addr.ruteSondag = entry.rute;
				addr.korelisteSondag = entry.koreliste;
			} else {
				
				if (StringUtils.equals(addr.ruteSondag, entry.rute) == false || StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
					addr.stateSon = AddressState.MODIFIED;
					addr.ruteSondag = entry.rute;
					addr.korelisteSondag = entry.koreliste;					
				}
			}
		}

		
		
	}
	
	
	
	private void createFromEntry(AddressSourceEntry entry) {
		System.out.println("Opretter adresse ud fra " + entry);
		
		Address a = new Address();
		a.state = AddressState.CREATED;
		
		a.distributor = entry.distributor;
		a.gadeid = entry.gadeid;
		a.kommunekode = entry.kommunekode;
		a.vejkode = entry.vejkode;
		a.vejnavn = entry.vejnavn;
		a.husnr = entry.husnr;
		a.husnrbogstav = entry.litra;
		a.postnr = entry.postnr;
		a.visited = true;
		
		if (entry.ugedage.mandag) {
			a.ruteMandag = entry.rute;
			a.korelisteMandag = entry.koreliste;
		}
		if (entry.ugedage.tirsdag) {
			a.ruteTirsdag = entry.rute;
			a.korelisteTirsdag = entry.koreliste;
		}
		if (entry.ugedage.onsdag) {
			a.ruteOnsdag = entry.rute;
			a.korelisteOnsdag = entry.koreliste;
		}		
		if (entry.ugedage.torsdag) {
			a.ruteTorsdag = entry.rute;
			a.korelisteTorsdag = entry.koreliste;
		}		
		if (entry.ugedage.fredag) {
			a.ruteFredag = entry.rute;
			a.korelisteFredag = entry.koreliste;
		}		
		if (entry.ugedage.lordag) {
			a.ruteLordag = entry.rute;
			a.korelisteLordag = entry.koreliste;
		}		
		if (entry.ugedage.sondag) {
			a.ruteSondag = entry.rute;
			a.korelisteLordag = entry.koreliste;
		}		
		
		// Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
		

		TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
		
		if (gade == null) {
			gade = new TreeMap<Short,ArrayList<Address>>();
			searchStructure.put(a.gadeid, gade);
		}
		
		ArrayList<Address> litraList = gade.get(a.husnr);
		if (litraList == null) {
			litraList = new ArrayList<Address>();
			gade.put(a.husnr, litraList);
		}
		
		litraList.add(a);
		addressList.add(a);
				
	}
	
	public List<Address> getAddressList() {
		return Collections.unmodifiableList(addressList);
	}
	
	public int getAfvistAntal() {
		return afvisteEntries.size();
	}
	
}