package de.mpiwg.gazetteer.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import org.apache.log4j.Logger;
import org.hibernate.Session;

import de.mpiwg.gazetteer.bo.LGBranch;
import de.mpiwg.gazetteer.bo.LGFile;
import de.mpiwg.gazetteer.utils.exceptions.NoAuthorizedException;
import de.mpiwg.gazetteer.utils.exceptions.VersioningException;

public class DataProvider extends AbstractDataProvider{
	
	private static Logger logger = Logger.getLogger(DBService.class);
	private static DataProvider instance;
	
	public static DataProvider getInstance(){
		if(instance == null)
			instance = new DataProvider();
		return instance;
	}
	
	public DataProvider(){
		logger.info("##### Starting DataProvider #####");
	}
	
	public LGFile getFile(Long fileId){
		return getFileMap().getValuesByOwnKey(fileId);
	}
	
	public List<LGFile> getAllFiles(Long branchId){
		List<LGFile> list = getFileMap().getValuesByAKey(branchId);
		Collections.sort(list);
		Collections.reverse(list);
		return list;
	}
	
	public List<LGBranch> getBranches(Long userId){
		List<LGBranch> list = new ArrayList<LGBranch>();
		for(LGBranch branch : getBranchMap().values()){
			if(branch.hasContributor(userId)){
				list.add(branch);
			}
		}
		return list;
	}
	
	public LGBranch getBranch(Long branchId){
		return getBranchMap().getValuesByOwnKey(branchId);
	}
	
	public void deleteFile(LGFile file) throws Exception{
	
		LGBranch branch = getBranch(file.getBranchId());
		
		if(branch == null){
			throw new Exception("There is any Branch for " + file);
		}
		
		List<LGFile> files = getAllFiles(file.getBranchId());
		
		if(files.size() == 1){
			throw new Exception("This file could not be deleted, because it is part of a branch that has only one file. A Branch without files is a inconsistency.");
		}
		
		// if the file is the last version of a branch, we must replace the current file with the penultimate file.
		if(branch.getCurrentLastFileId().equals(file.getId())){
			LGFile penultimateFile = getPenultimateFile(files);
			
			penultimateFile.setLastVersion(true);
			branch.setCurrentLastFileId(penultimateFile.getId());
			
			this.updateBranch(branch);
			this.updateFile(penultimateFile);
			
		}
		
		//deleting file from DB and cache
		int modifiedFiles = DBService.deleteFileFromDB(file.getId());
		getFileMap().remove(file.getKey());
		
		logger.info(modifiedFiles + " items deleted by removing file " + file);
	}
	
	private LGFile getPenultimateFile(List<LGFile> files){
		LGFile penultimateFile = null;
		LGFile lastFile = null;
		
		for(LGFile file : files){
			if(lastFile == null){
				lastFile = file;
			}else if(penultimateFile == null){
				lastFile = (lastFile.getVersion() > file.getVersion()) ? lastFile : file;
				penultimateFile = (lastFile.getVersion() < file.getVersion()) ? lastFile : file;
			}else{
				if(file.getVersion() > lastFile.getVersion()){
					penultimateFile = lastFile;
					lastFile = file;
				}else if(file.getVersion() > penultimateFile.getVersion()){
					penultimateFile = file;
				}
			}
		}
		
		return penultimateFile;
	}
	
	public void deleteBranch(LGBranch branch){
		
		int modifiedFiles = DBService.deleteBranchFromDB(branch.getId());
		List<LGFile> fileToDelete = getFileMap().getValuesByAKey(branch.getId());
		
		for(LGFile file : new ArrayList<LGFile>(fileToDelete)){
			getFileMap().remove(file.getKey());
		}
		getBranchMap().remove(branch.getKey());

		logger.info(modifiedFiles + " items deleted by removing branch " + branch.toString());
	}
	
	public void updateFile(LGFile file) throws Exception{
		if(!file.isPersistent()){
			throw new Exception("Trying to update a file that it is not persistent!");
		}
		
		Date date = new Date();
		DBService.saveDBEntry(file, date);
		this.getFileMap().put(file.getKey(), file);
	}
	
	public void updateBranch(LGBranch branch) throws Exception{
		if(!branch.isPersistent()){
			throw new Exception("Trying to update a branch that it is not persistent!");
		}
		
		Date date = new Date();
		DBService.saveDBEntry(branch, date);
		this.getBranchMap().put(branch.getKey(), branch);
	}
	
	public LGFile saveFile(Long branchId, String text, Long userId, Long userPreviousFileId) throws Exception{
		
		
		
		Date date = new Date();
		
		LGBranch branch = getBranchMap().getValuesByOwnKey(branchId);
		
		if(!branch.hasContributor(userId)){
			throw new NoAuthorizedException(userId, branchId);
		}
		
		if(!branch.getCurrentLastFileId().equals(userPreviousFileId)){
			LGFile userPreviousFile = getFileMap().getValuesByOwnKey(userPreviousFileId);
			LGFile currentLastFile = getFileMap().getValuesByOwnKey(branch.getCurrentLastFileId());
			
			throw new VersioningException(userPreviousFile, currentLastFile);
		}
		
		LGFile previousFile = getFileMap().getValuesByOwnKey(branch.getCurrentLastFileId());
		
		LGFile file = new LGFile();
		file.setBranchId(branchId);
		file.setVersion(previousFile.getVersion() + 1);
		file.setUserId(userId);
		file.setContent(text);
		
		//Saving into DB
		//##################################
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.getTransaction().begin();
		
		
		file.setBranchId(branch.getId());
		DBService.saveDBEntry0(session, file, date);
		
		previousFile.setLastVersion(false);
		DBService.saveDBEntry0(session, previousFile, date);
		
		branch.setCurrentLastFileId(file.getId());
		DBService.saveDBEntry0(session, branch, date);
		
		//Saving physical file in the operating system
		String fileName = FileManager.saveFile(branch, file, date, userId);
		file.setFileName(fileName);
		DBService.saveDBEntry0(session, file, date);
		
		session.getTransaction().commit();
		//##################################
		
		
		//Saving into Cache
		getBranchMap().put(branch.getKey(), branch);
		getFileMap().put(file.getKey(), file);
		getFileMap().put(previousFile.getKey(), previousFile);
		
		return file;
	}
	
	public Long saveNewFile(String text, String label, Long sectionId, Long userId) throws Exception{
		
		Date date = new Date();
		
		LGBranch branch = new LGBranch();				
		branch.setSectionId(sectionId);
		branch.setUserId(userId);
		branch.setLabel(label);
		branch.addContributor(userId);
		branch.loadTransientData();
		
		LGFile file = new LGFile();
		file.setUserId(userId);
		file.setContent(text);
		
		//Saving into DB
		//##################################
		Session session = HibernateUtil.getSessionFactory().getCurrentSession();
		session.getTransaction().begin();
		
		DBService.saveDBEntry0(session, branch, date);
		file.setBranchId(branch.getId());
		
		DBService.saveDBEntry0(session, file, date);
		branch.setCurrentLastFileId(file.getId());

		//Saving physical file in the operating system
		String fileName = FileManager.saveFile(branch, file, date, userId);
		file.setFileName(fileName);
		DBService.saveDBEntry0(session, file, date);
		
		session.getTransaction().commit();
		//##################################
		
		
		//Saving into Cache
		getBranchMap().put(branch.getKey(), branch);
		getFileMap().put(file.getKey(), file);
		
		return branch.getId();
		
	}
}