package org.mpi.openmind.scripts.recovery;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.ConsoleAppender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.mpi.openmind.cache.WrapperService;
import org.mpi.openmind.repository.bo.Attribute;
import org.mpi.openmind.repository.bo.Entity;
import org.mpi.openmind.repository.bo.Node;
import org.mpi.openmind.repository.bo.Relation;
import org.mpi.openmind.repository.services.ServiceRegistry;
import org.mpi.openmind.repository.utils.OMUtils;

public class SaxXmlRecovery {

	private static Logger logger = Logger.getLogger(SaxXmlRecovery.class);

	private static String user = "recovery_";

	static {

		Date dNow = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
		user = user + dateFormat.format(dNow);

		ConsoleAppender console = new ConsoleAppender(); // create appender
		// configure the appender
		String PATTERN = "%d [%p|%c{1}:%L] %m%n";
		console.setLayout(new PatternLayout(PATTERN));
		console.setThreshold(Level.INFO);
		console.activateOptions();
		// add appender to any Logger (here is root)
		Logger.getRootLogger().addAppender(console);

		/*
		FileAppender fa = new FileAppender();
		fa.setName("FileLogger");
		fa.setFile("/Users/jurzua/test.log");

		fa.setLayout(new PatternLayout(PATTERN));
		fa.setThreshold(Level.INFO);
		fa.setAppend(true);
		fa.activateOptions();
		
		Logger.getRootLogger().addAppender(fa);
		*/

	}

	public static void executeEnts(String file) {
		long start = System.currentTimeMillis();
		try {
			EntitySAXReader reader = new EntitySAXReader();
			RecoveryCache xmlCache = reader.execute(file);
			ServiceRegistry services = new ServiceRegistry();
			WrapperService ws = services.getWrapper();

			Map<Long, Long> idMap = new HashMap<Long, Long>();
			
			idMap = saveEnts(ws, xmlCache, idMap);
			
			saveRels(ws, xmlCache, idMap);
			
			logger.info("\n" +
					"**************************\n" +
					"Summary:\n" +
					"timeExecution=\t" + (System.currentTimeMillis() - start));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void executeDefs(String file) {
		long start = System.currentTimeMillis();
		try {
			EntitySAXReader reader = new EntitySAXReader();
			RecoveryCache xmlCache = reader.execute(file);
			ServiceRegistry services = new ServiceRegistry();
			WrapperService ws = services.getWrapper();

			Map<Long, Long> idMap = new HashMap<Long, Long>();
			
			saveDefs(ws, xmlCache, idMap);
			saveDefRels(ws, xmlCache, idMap);
			
			System.out.println(idMap.size());
			
			logger.info("\n" +
					"**************************\n" +
					"Summary:\n" +
					"timeExecution=\t" + (System.currentTimeMillis() - start));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void saveDefs(WrapperService ws, RecoveryCache xmlCache, Map<Long, Long> idMap) throws Exception {
		
		int i = 0;
		int size = xmlCache.getEnts().size();
		
		for(Entity xmlEnt : xmlCache.getEnts()){
			Long oldId = xmlEnt.getId();
			xmlEnt.resetId();
			xmlEnt.resetRowId();
			
			//xmlEnt = ws.saveEntity(xmlEnt, user);
			ws.saveLWDefinition(xmlEnt, user);
			for(Attribute att : xmlEnt.getAttributes()){
				att.loadEntValue(xmlEnt);
				ws.saveDefAttribute(att, user);
			}			
			idMap.put(oldId, xmlEnt.getId());
			if (i % 100 == 0) {
				logger.info(i + " entities loaded. " + OMUtils.percentage(i, size)
						+ "%.");
			}
			i++;
		}
	}
	
	private static Map<Long, Long> saveEnts(WrapperService ws, RecoveryCache xmlCache, Map<Long, Long> idMap) throws Exception {
		//ws.getPS().setImportModus(true); no alternative method to generate the ownvalue
		idMap = ws.saveEntityListAsNew(new ArrayList<Entity>(xmlCache.getEnts()), user, false);
		return idMap;
	}
	
	private static void saveDefRels(WrapperService ws, RecoveryCache xmlCache, Map<Long, Long> idMap) throws Exception {
		
		int i = 0;
		int size = xmlCache.getRels().size();
		
		for(Relation xmlRel : xmlCache.getRels()){
			
			xmlRel.setSourceId(idMap.get(xmlRel.getSourceId()));
			xmlRel.setTargetId(idMap.get(xmlRel.getTargetId()));
			
			Relation rel = Relation.defRelation(xmlRel, ws);
			
			rel.setId(null);
			rel.setRowId(null);
			
			
			ws.saveDefRelation(rel, user);
			if (i % 100 == 0) {
				logger.info(i + " relations loaded. " + OMUtils.percentage(i, size)
						+ "%.");
			}
			i++;
		}
	}
	
	private static void saveRels(WrapperService ws, RecoveryCache xmlCache, Map<Long, Long> idMap) throws Exception {
		
		List<Node> relList = new ArrayList<Node>();
		for(Relation xmlRel : xmlCache.getRels()){
			
			xmlRel.setSourceId(idMap.get(xmlRel.getSourceId()));
			xmlRel.setTargetId(idMap.get(xmlRel.getTargetId()));
			
			Relation rel = Relation.entRelation(xmlRel, ws);
			
			rel.setId(null);
			rel.setRowId(null);
			
			relList.add(rel);
		}
		ws.saveNodeListOnlyForScripts(relList, user);
		
	}
	
	
	/*
	private static int removingEntsFromDB(WrapperService ws,
			RecoveryCache xmlCache) throws Exception {
		logger.info("1)################# Removing ################");
		
		int counter = 0;
		
		for (Entity def : ws.getConcepts()) {
			logger.info(def.getOwnValue());
			for (Entity dbEnt : ws.getEntitiesByDef(def.getOwnValue())) {
				if (!xmlCache.existEnt(dbEnt.getId())) {
					logger.info("\nthis must be removed from DB=" + dbEnt);
					ws.removeCurrentVersionEntity(dbEnt);
					counter++;
				}
			}
		}
		return counter;
	}

	private static int createNewEnts(WrapperService ws, RecoveryCache xmlCache)
			throws Exception {
		logger.info("2)################# Creating ################");
		int i = 0;
		Collection<Entity> xmlEnts = xmlCache.getEnts();
		int size = xmlEnts.size();
		int entsCreated = 0;
		
		List<Entity> tmpEnts = new ArrayList<Entity>();
		
		for (Entity xmlEnt : xmlEnts) {
			if (!ws.existEntity(xmlEnt.getId())) {
				logger.info("\nThis entity must be created " + xmlEnt);

				// xmlEnt.setSourceRelations(xmlCache.getRelBySrc(xmlEnt.getId()));
				// xmlEnt.setTargetRelations(xmlCache.getRelByTar(xmlEnt.getId()));

				//ws.saveEntity(xmlEnt, user);
				tmpEnts.add(xmlEnt);
				entsCreated++;
			}
			if (i % 100 == 0) {
				logger.info(i + " entities loaded. " + percentage(i, size)
						+ "%.");
			}
			i++;
		}
		
		ws.saveEntityList(tmpEnts, user);

		return entsCreated;
	}
	
	private static int refreshEnts(WrapperService ws, RecoveryCache xmlCache)
			throws Exception {
		logger.info("3)################# Refresing ################");
		int counter = 0;
		
		List<Entity> tmpEnts = new ArrayList<Entity>();
		
		for (Entity xmlEnt : xmlCache.getEnts()) {
			
			if(xmlEnt.getId().equals(Long.parseLong("423011"))){
				System.out.println();
			}
			if(xmlEnt.getId().equals(Long.parseLong("449780"))){
				System.out.println();
			}
			
			xmlEnt.setSourceRelations(xmlCache.getRelBySrc(xmlEnt.getId()));
			xmlEnt.setTargetRelations(xmlCache.getRelByTar(xmlEnt.getId()));
			xmlEnt.setLightweight(false);		
			
			Entity dbEnt = ws.getEntityByIdWithContent(xmlEnt.getId());

			if (!dbEnt.equalsContent(xmlEnt)) {
				logger.info("\nRefreshing " + dbEnt);
				dbEnt.refreshEnt(xmlEnt, ws);
				
				//ws.saveEntity(dbEnt, user);
				tmpEnts.add(dbEnt);
				counter++;
			}
		}
		
		ws.saveEntityList(tmpEnts, user);
		
		return counter;
	}
	 */

	public static void main(String[] args) {
		
		String s = args[0];
		
		if(StringUtils.equals(s, "ents")){
			executeEnts("/Users/jurzua/Projects/max-planck/db_backup/xml_backup/2013.07.12-ENT.xml");
		}else if(StringUtils.equals(s, "rels")){
			executeDefs("/Users/jurzua/Projects/max-planck/db_backup/xml_backup/2013.07.12-DEF.xml");
		}
		
		System.exit(0);
	}

}