package de.mpiwg.gazetteer.utils;

import java.io.IOException;
import java.sql.SQLException;
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 org.hibernate.Transaction;

import cl.maps.duplex.DuplexKey;
import de.mpiwg.gazetteer.bo.LGBranch;
import de.mpiwg.gazetteer.bo.LGFile;
import de.mpiwg.gazetteer.bo.LGFullTextSearchFile;
import de.mpiwg.gazetteer.bo.LGTaglist;
import de.mpiwg.gazetteer.bo.LGTopic;
import de.mpiwg.gazetteer.bo.LGTopicSectionRelation;
import de.mpiwg.gazetteer.bo.LGTopicTagRelation;
import de.mpiwg.gazetteer.db.DBContents;
import de.mpiwg.gazetteer.db.DBSection;
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(DataProvider.class);
	private static DataProvider instance;

	public static DataProvider getInstance(){
		if(instance == null)
			instance = new DataProvider();
		return instance;
	}

	public static void resetInstance() {
		instance = null;
	}

	public DataProvider(){
		logger.info("##### Starting DataProvider #####");
	}



	/* --- branch --- */

	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<LGTopicSectionRelation> getAllExistingTopicSectionRelation() {
		List<LGTopicSectionRelation> list = new ArrayList<LGTopicSectionRelation>();
		for (LGTopicSectionRelation relation : getTopicSectionRelationMap().values()) {
			list.add(relation);
		}
		return list;
	}

	public List<LGBranch> getAllExistingBranches(){
		List<LGBranch> list = new ArrayList<LGBranch>();
		for(LGBranch branch : getBranchMap().values()){
			list.add(branch);
		}
		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().openSession();
		Transaction tx = null;

		try{

			  tx = session.beginTransaction();

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

		    tx.commit();

				//##################################

				//Saving into Cache
				getBranchMap().put(branch.getKey(), branch);
				getFileMap().put(file.getKey(), file);
				getFileMap().put(previousFile.getKey(), previousFile);

		}catch (Exception e) {

			 if (tx!=null) tx.rollback();

			 e.printStackTrace();

			 throw e;

		}finally {
			 session.close();
		}

		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().openSession();
		Transaction tx = null;
    try{
         tx = session.beginTransaction();

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

					tx.commit();

					//Saving into Cache
					getBranchMap().put(branch.getKey(), branch);
					getFileMap().put(file.getKey(), file);

    }catch (Exception e) {
       if (tx!=null) tx.rollback();

			 e.printStackTrace();

       throw e;
    }finally {
       session.close();
    }
		//##################################

		return branch.getId();

	}

	/* --- end branch --- */



	/* --- full text search --- */

	public List<LGFullTextSearchFile> getSearchFileList4User(Long userId) {

		List<LGFullTextSearchFile> list = new ArrayList<LGFullTextSearchFile>();

		for(LGFullTextSearchFile searchFile : getFullTextSearchFileMap().values()){
			if(searchFile.getUserId() == userId){
				list.add(searchFile);
			}
		}

		return list;
	}




	public void deleteLGFullTextSearchFile(LGFullTextSearchFile file) throws IOException{
		//deleting file from DB: the record in table FullTextSearchFile
		int modifiedFiles = DBService.deleteFullTextSearchFileFromDB(file.getId());

		// delete the files from file system (html in ftsearch-data/... and csv in LGMap/datasets/)
		FileManager.deleteFullTextSearchFileCsv(file);
		FileManager.deleteFullTextSearchFileHtml(file);

		// delete file from cache
		this.getFullTextSearchFileMap().remove(file.getKey());
		logger.debug("deleteLGFullTextSearchFile");
	}

	public LGFullTextSearchFile saveLGFullTextSearchFile(List<DBContents> list, Long userId, LGFullTextSearchFile searchFile) throws Exception {
		// save as csv and html file in filesystem, and records in db `FullTextSearchFile
		// List<DBContents> list is the filteredList of searching result with isRemoved field

		Date date = new Date();

		//Saving into DB
		//##################################
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = null;
    try{
         tx = session.beginTransaction();

		     DBService.saveDBEntry0(session, searchFile, date);

				 //Saving physical file in the operating system
				 FileManager.saveFullTextSearchFileAsCsv(searchFile, userId, list);	// save csv file to LGMap's datasets folder
				 FileManager.saveFullTextSearchFileAsHtml(searchFile, userId, list);	// save html file to LGMap's datasets folder

				 tx.commit();
		}catch (Exception e) {
         if (tx!=null) tx.rollback();

				 e.printStackTrace();

         throw e;
    }finally {
       session.close();
    }
		//##################################

		return searchFile;
	}

	public LGFullTextSearchFile getFullTextSearchFile(Long fileId) {

		LGFullTextSearchFile file = getFullTextSearchFileMap().getValuesByOwnKey(fileId);

		return file;
	}

	/* --- end full text search --- */

	/* --- topic --- */

	public List<LGTopic> getTopics(Long userId){
		List<LGTopic> list = new ArrayList<LGTopic>();
		for(LGTopic topic : getTopicMap().values()){
			/*
			if(topic.hasContributor(userId)){
				list.add(topic);
			}
			*/

			// add topic into list anyway, without checking the contributor role.
			list.add(topic);
		}

		return list;
	}

	public LGTopic getTopic(Long topicId){
		return getTopicMap().getValuesByOwnKey(topicId);
	}


	public void deleteTopic(LGTopic topic){

		int modifiedRelation = DBService.deleteTopicFromDB(topic.getId());
		getTopicMap().remove(topic.getKey());

		logger.info("removing " + modifiedRelation + " records in TopicSectionRelation and TopicTagRelation table for the topic " + topic.toString());

		this.setTopicSectionRelationMap(null);	// clear topicSectionRelationMap cache

	}

	public void createTopic(String nameEn, String nameCh,String namePinyin, String description, Long userId) {

		Date date = new Date();

		LGTopic topic = new LGTopic();
		topic.setNameEn(nameEn);
		topic.setNameCh(nameCh);
		topic.setNamePinyin(namePinyin);
		topic.setDescription(description);
		topic.setUserId(userId);
		topic.setContributors("[" + userId.toString() + "]");

		// auto-generating a tag for the topic: could be from nameEn replace space with '_'
		String tag = new String();
		tag = nameEn.replace(' ', '_');
		topic.setTag(tag);

		//Saving into DB
		//##################################
		// For Topic table
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = null;
		try{
				tx = session.beginTransaction();

				DBService.saveDBEntry0(session, topic, date);

				// For Taglist table
				// create record, which is the topic tag, in taglist table,
				// with the taglis.name=nameCh, the taglist.tag=tag, the taglist.color=the defualt topic tag color, which is rgb(255,0,174)

				LGTaglist taglist = new LGTaglist();
				taglist.setName(nameCh);

				// tag to lowercase only!! bcuz it will be used as topic tag in Extraction-interface, and it'll be a tag in HTML which is case-insensitive
				taglist.setTag(tag.toLowerCase());

				taglist.setColor("rgb(255, 0, 174)");

				DBService.saveDBEntry0(session, taglist, date);

		    logger.debug("new topic tag id=" + taglist.getId());

				// For TopicTagRelation table
				// link the relation between the new topic and its corresponding tag
				LGTopicTagRelation relation = new LGTopicTagRelation();
				relation.setTagId(taglist.getId());
				relation.setTopicId(topic.getId());

				DBService.saveDBEntry0(session, relation, date);

				tx.commit();

    }catch (Exception e) {
       if (tx!=null) tx.rollback();

			 e.printStackTrace();

       throw e;
    }finally {
       session.close();
    };
		//##################################

	}

	public void updateTopic(LGTopic topic) throws Exception {
		if(!topic.isPersistent()){
			throw new Exception("Trying to update a topic that it is not persistent!");
		}

		Date date = new Date();
		DBService.saveDBEntry(topic, date);
		this.getTopicMap().put(topic.getKey(), topic);

	}



	public List<DBSection> getAllSectionsInTopic(Long topicId) throws SQLException{

		List<LGTopicSectionRelation> topicSectionRelationList = getTopicSectionRelationMap().getValuesByAKey(topicId);

		// get sections from topicSecionRelation list
		List<DBSection> list = new ArrayList<DBSection>();
		for (LGTopicSectionRelation aRelation : topicSectionRelationList) {
			//logger.debug(aRelation.getInfo() );

			DBSection section = DBService.getSectionWithContent(aRelation.getSectionId());
			list.add(section);

		}


		Collections.sort(list);
		Collections.reverse(list);
		return list;
	}




	public void deleteTopicSectionRelation(Long topicId, String bookId) throws Exception{
		// delete record with topicId, bookId in topicSectionRelation
		// this means the sectionId = 0, there is no corresponding section in the book for this topic

		// TODO

	}

	public void deleteTopicSectionRelation(Long topicId, Long sectionId) throws Exception{
		if (sectionId == 0) {
			throw new Exception("sectionId cannot be 0");
		}

		DuplexKey<Long, Long> key = new DuplexKey<Long, Long>(topicId, sectionId);
		LGTopicSectionRelation topicSectionRelation = this.getTopicSectionRelationMap().get(key);

		LGTopic topic = getTopic(topicId);

		if(topic == null){
			throw new Exception("There is no topic of " + topicSectionRelation);
		}

		//deleting topicSectionRelation from DB and cache
		int modifiedRelation = DBService.deleteTopicSectionRelationFromDB(topicSectionRelation.getId());
		getTopicSectionRelationMap().remove(topicSectionRelation.getKey());

		logger.info(modifiedRelation + " items deleted by removing topicSectionRelation " + topicSectionRelation.toString());


	}

	public String updateTopicSectionRelation(Long sectionId, Long topicId) throws Exception {
		DuplexKey<Long, Long> key = new DuplexKey<Long, Long>(topicId, sectionId);
		LGTopicSectionRelation topicSectionRelation = this.getTopicSectionRelationMap().get(key);

		if (topicSectionRelation != null) {
			// the relation already existed
			// would this possibly need any modification to the existing record in the topicSectionRelation table?

			return "updated";

		} else {
			createTopicSectionRelation(sectionId, topicId);

			return "added";
		}



	}


	public void createTopicSectionRelation(Long sectionId, Long topicId) throws Exception {

		Date date = new Date();

		LGTopicSectionRelation topicSectionRelation = new LGTopicSectionRelation();
		topicSectionRelation.setTopicId(topicId);
		topicSectionRelation.setSectionId(sectionId);

		DBService.getInstance();
		DBSection section = DBService.getSectionWithContent(sectionId);
		topicSectionRelation.setBookId(section.getBookId());

		//Saving into DB
		//##################################
		// For Topic table
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = null;
    try{
       tx = session.beginTransaction();
       DBService.saveDBEntry0(session, topicSectionRelation, date);
       tx.commit();
    }catch (Exception e) {
       if (tx!=null) tx.rollback();
       e.printStackTrace();
			 throw e;
    }finally {
       session.close();
    }

		// update cache
		this.loadTopicSectionRelations();

	}

	public Integer getNumberOfSectionInTopic(Long topicId) {
		List<LGTopicSectionRelation> topicSectionRelationList = getTopicSectionRelationMap().getValuesByAKey(topicId);

		return topicSectionRelationList.size();
	}



	/* --- end topic --- */

}