package foundation.io;

import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import foundation.dao.DataPackage;
import foundation.dao.DataReader;
import foundation.dao.Filter;
import foundation.dao.PackageItem;
import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldsRuntime;
import foundation.data.object.DataObject;
import foundation.io.define.AppendMode;
import foundation.io.define.DataIO;
import foundation.io.define.DataIOContainer;
import foundation.io.define.IODirection;
import foundation.io.define.IOSQLContext;
import foundation.io.define.IOSource;
import foundation.io.define.IOTask;
import foundation.io.mapping.FieldMapping;
import foundation.io.mapping.IOMappings;
import foundation.util.ID;
import foundation.util.Util;

public class IOCreator {

	private static Logger logger;
    private static Object ioCreatorLocker = new Object();
    
    static {
    	logger = LogManager.getLogger(IOCreator.class);
    }

	public static IOTask createTask(DataReader dataReader, String taskName, IODirection direction) throws Exception {
		synchronized (ioCreatorLocker) {
			//1. 得到 data package
			String dataName = dataReader.getString("dataname");
			
			if (Util.isEmpty(dataName)) {
				dataName = taskName;
			}
			
			DataPackage dataPackage = DataPackage.getInstance(dataName);
			
			if (dataPackage == null) {
				logger.error("data package not exist, io exit", dataName);
				return null;
			}
			
			//2. 创建 Task
			logger.error("task {} not exist, create default", taskName);
			IOTask ioTask = new IOTask(IOSource.AutoCreate);
			ioTask.setName(taskName);
			
			//3. 创建 DataIO（根据Package中包含的对象的个数创建）
			createDataIOs(dataReader, ioTask, dataPackage, direction);
			
			//4.
			return ioTask;
		}
	}
	
	public static IOTask createDownloadErrorsTask(DataReader dataReader, String taskName, String ioBatchId) throws Exception {
		//1. 获取导入信息
		DataIOContainer ioContainer = DataIOContainer.getInstance();
		IOTask ioTask = ioContainer.getIOTask(taskName);
		DataIO importDataIO = ioTask.getDataIO(0);
		DataObject tempObject = importDataIO.getToTempDataObject();
		Filter filter = new Filter("io_batch_id", ioBatchId);
		
		//2. 创建 Task
		ioTask = new IOTask(IOSource.AutoCreate);
		ioTask.setName(taskName);
		
		//3. 创建 DataIO（根据Package中包含的对象的个数创建）
		DataIO dataIO = createOneDataIO(dataReader, tempObject, IODirection.ErrorsToSheet, filter);
		dataIO.setTemplateName(importDataIO.getTemplateName());
		dataIO.setMappingId(importDataIO.getMappingId());
		ioTask.addDataIO(dataIO);
		
		return ioTask;
	}

	private static void createDataIOs(DataReader dataReader, IOTask task, DataPackage dataPackage, IODirection direction) throws Exception {
		boolean isAll = dataReader.getBoolean("is_all", false);
		DataIO dataIO; 
		
		//1. create DataIO on main
		DataObject masterObject = dataPackage.getMasterDataObject();
		Filter filter = createMainFilter(dataReader, masterObject);
		
		dataIO = createOneDataIO(dataReader, masterObject, direction, filter);
		task.addDataIO(dataIO);
		
		if (!isAll) {
			return;				
		}
		
		//2. create DataIO on slaves
		List<PackageItem> slaves = dataPackage.getSlaveItems();
		
		for (PackageItem packageItem: slaves) {
			DataObject slaveObject = packageItem.getDataObject();
			filter = createSlaveFilter(masterObject, slaveObject, filter);
			
			dataIO = createOneDataIO(dataReader, slaveObject, direction, filter);
			task.addDataIO(dataIO);
		}
	}
	
	private static DataIO createOneDataIO(DataReader dataReader, DataObject dataObject, IODirection direction, Filter filter) throws Exception {
		DataIO dataIO = new DataIO();
		
		//1. 
		String dataName = dataObject.getDataName();
		dataIO.setId(dataName);
		dataIO.setTaskName(dataName);
		dataIO.setWriteTitle(true);
		dataIO.setSource(IOSource.AutoCreate);
		dataIO.setAction(dataReader.getString("io_action"));
		dataIO.setActionMethod(dataReader.getString("io_action_method"));
		
		if (IODirection.TableToSheet == direction) {
			dataIO.setFromName(dataName);
			dataIO.setToName(dataObject.getTitle());
			dataIO.setFileName(dataObject.getTitle() + "@{-YYYYMMdd}.xlsx");
		}
		else if (IODirection.SheetToTable == direction) {
			dataIO.setFromName(null);
			dataIO.setToName(dataName);
			dataIO.setFileName(dataObject.getTitle() + "@{-YYYYMMdd}.xlsx");
		}
		else if (IODirection.SheetToMemory == direction) {
			dataIO.setFromName(null);
			dataIO.setToName(dataName);
			dataIO.setFileName(dataObject.getTitle() + "@{-YYYYMMdd}.xlsx");
		}
		else if (IODirection.ErrorsToSheet == direction) {
			dataIO.setFromName(dataName);
			dataIO.setToName("导入反馈");
			dataIO.setFileName(dataObject.getTitle() + "@{-YYYYMMdd}.xlsx");
			dataIO.setToTempName(dataName);
		}

		dataIO.setDirection(direction);
		
		AppendMode appendMode = AppendMode.parse(dataReader.getString("append_mode"), AppendMode.Append);
		dataIO.setAppendMode(appendMode);
		
		//2.
		IOSQLContext ioContext = dataIO.getContext();
		ioContext.setDynamicFilter(filter);
		
		//3.
		dataIO.setTemplateName(FileRepository.Default_Template);
		return dataIO;
	}

	public static IOMappings createIOMappings(DataIO dataIO) throws Exception {
		IODirection direction = dataIO.getDirection();
		String dataName = null;
		
		if (IODirection.SheetToTable == direction) {
			dataName = dataIO.getToName();
		}
		else if (IODirection.SheetToMemory == direction) {
			dataName = dataIO.getToName();
		}
		else if (IODirection.TableToSheet == direction) {
			dataName = dataIO.getFromName();
		}
		else if (IODirection.TableToTable == direction) {
			dataName = dataIO.getToName();
		}
		else {
			throw new Exception("data io error, direstion is empty: " + dataIO.getId());
		}		
		
		DataObject dataObject = DataObject.getInstance(dataName);
		IOMappings ioMappings = doCreateIOMappings(dataObject, direction);
		
		return ioMappings;
	}
	
	public static IOMappings doCreateIOMappings(DataObject dataObject, IODirection direction) throws Exception {
		String dataName = dataObject.getDataName();
		
		//1. 
		IOMappings mapping = new IOMappings(IOSource.AutoCreate);
		
		mapping.setId(dataName);
		mapping.setName(dataName);
		mapping.setOpen(true);
		
		//2.
		if (IODirection.TableToSheet == direction) {
			FieldsRuntime fieldMetas = dataObject.getBatchBrowseFieldMetas();
			
			for (Field field: fieldMetas) {
				if (!field.isExportable()) {
					continue;
				}
				
				FieldMapping fieldMapping = new FieldMapping();
				fieldMapping.setId(ID.newValue());
				fieldMapping.setParentId(dataName);
				
				fieldMapping.setFromName(field.getName());
				fieldMapping.setToName(field.getLabelChinese());				
				
				mapping.addFieldMapping(fieldMapping);
			}
		}
		else if (IODirection.SheetToTable == direction) {
			FieldsRuntime fieldsMeta = dataObject.getBatchBrowseFieldMetas();
			
			for (Field field: fieldsMeta) {
				if (!field.isImportable()) {
					continue;
				}
				
				FieldMapping fieldMapping = new FieldMapping();
				fieldMapping.setId(ID.newValue());
				fieldMapping.setParentId(dataName);
				
				fieldMapping.setFromName(field.getLabelChinese());
				fieldMapping.setToName(field.getName());				
				
				mapping.addFieldMapping(fieldMapping);
			}
		}
		else if (IODirection.SheetToMemory == direction) {
			FieldsRuntime fieldsMeta = dataObject.getBatchBrowseFieldMetas();
			
			for (Field field: fieldsMeta) {
				if (!field.isImportable()) {
					continue;
				}
				
				FieldMapping fieldMapping = new FieldMapping();
				fieldMapping.setId(ID.newValue());
				fieldMapping.setParentId(dataName);
				
				fieldMapping.setFromName(field.getLabelChinese());
				fieldMapping.setToName(field.getName());				
				
				mapping.addFieldMapping(fieldMapping);
			}
		}
		else if (IODirection.TableToTable == direction) {
			FieldsRuntime fieldsMeta = dataObject.getTableFieldMetas();
			
			for (Field field: fieldsMeta) {
				FieldMapping fieldMapping = new FieldMapping();
				fieldMapping.setId(ID.newValue());
				fieldMapping.setParentId(dataName);
				fieldMapping.setFromName(field.getName());
				fieldMapping.setToName(field.getName());
				
				mapping.addFieldMapping(fieldMapping);
			}			
		}		
		
		return mapping;
	}

	private static Filter createMainFilter(DataReader requestReader, DataObject dataObject) throws Exception {
		if (!requestReader.containsVariant("filter")) {
			return null;
		}
		
		Filter filter = new Filter();
		requestReader.loadFilterFromJSON(dataObject, filter);
		
		return filter;
	}

	private static Filter createSlaveFilter(DataObject masterObject, DataObject detailObject, Filter masterFilter) {
		if (masterFilter == null) {
			return null;
		}
		
		String masterTable = masterObject.getTableName();
		String detailTable = detailObject.getTableName();
		
		StringBuilder sql = new StringBuilder();
		sql.append(" exists (");
		sql.append(" select 1 from ").append(masterTable).append(" where");
		sql.append("  and ").append(masterTable).append(".id = ").append(detailTable).append(".parent_id");
		sql.append(")");
		
		Filter filter = new Filter(sql.toString());
		return filter;
	}

}