package foundation.state;

import java.util.List;

import foundation.action.EventWorkSteps;
import foundation.action.Events;
import foundation.action.WorkStep;
import foundation.action.WorkflowDispatcher;
import foundation.dao.Filter;
import foundation.dao.OrderBy;
import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.data.meta.field.Field;
import foundation.data.meta.field.FieldsRuntime;
import foundation.data.object.DataObject;
import foundation.data.rule.FieldDefaultValueCreator;
import foundation.data.rule.FieldDefaultValueRule;
import foundation.data.rule.FieldRules;
import foundation.data.rule.RuleSource;
import foundation.server.Initializer;
import foundation.state.approve.ApproveRuntime;
import foundation.state.approve.ApproveRuntimeBucket;
import foundation.state.approve.ApproveTemplate;
import foundation.state.approve.Step;
import foundation.state.approve.StepBoard;
import foundation.state.approve.StepBoardBucket;
import foundation.state.approve.StepTemplate;
import foundation.state.approve.StepUser;
import foundation.util.Util;

public class StateMachineLoader extends Initializer {

	@Override
	public void startUp() throws Exception {
		MachineBucket bucket = MachineBucket.getInstance();
		
		//1. 加载审批委员会/审批人
		loadApproveStepBoard(bucket);
		
		//2. 加载审批流
		loadApproveFlow(bucket);
		
		//3. 加载状态列表
		loadStates(bucket);
		
		//4. 加载状态机
		loadStateMachine(bucket);
		
		//5. 加载消息
		loadStateMessages(bucket);
		
		//6. register object action 
		registerObjectActions(bucket);
		
		//7. register state provider
		registerStateProvider(bucket);
		
		//8. register state default value 
		registerStateDefaultValues(bucket);
	}

	public void loadStates(MachineBucket bucket) throws Exception {
		StatesBucket statesBucket = StatesBucket.getInstance();

		DataObject dataObject = DataObject.getInstance("sys_state_machine_state");
		OrderBy orderBy = new OrderBy("category_code, index_no");
		EntitySet entitySet = dataObject.getTableEntitySet(orderBy);
		
		for (Entity entity: entitySet) {
			State state = new State();
			state.load(entity);
			
			statesBucket.loadOneState(state);
		}
	}
	
	private void loadStateMachine(MachineBucket bucket) throws Exception {
		StatesBucket statesBucket = StatesBucket.getInstance();
		ApproveRuntimeBucket approveBucket = ApproveRuntimeBucket.getInstance();
		
		DataObject dataObject; EntitySet entitySet;
		
		//1. 加载状态机
		dataObject = DataObject.getInstance("sys_state_machine");
		entitySet = dataObject.getTableEntitySet();

		for (Entity entity: entitySet) {
			 StateMachine machine = new StateMachine();
			 machine.load(entity);
			 
			 if (!machine.isActive()) {
				 continue;
			 }
			 
			 String stateCategory = entity.getString("state_category_code");
			 States states = statesBucket.getCachedOne(stateCategory);
			 machine.setStates(states);
			 
			 bucket.loadOne(machine.getId(), machine);
		}
		
		//2. 分配状态机
		dataObject = DataObject.getInstance("sys_state_machine_target");
		entitySet = dataObject.getTableEntitySet();
		
		for (Entity entity: entitySet) {
			boolean active = entity.getBoolean("is_active", true);
			
			if (!active) { 
				continue;
			}
			
			String dataName = entity.getString("package_name");
			String machineId = entity.getString("state_machine_id");
			
			StateMachine machine = bucket.get(machineId);
			if (machine == null) {
				continue;
			}	
			
			machine.loadTarget(dataName);
			bucket.loadtarget(dataName, machine);
		}
		
		//3. load machine points, state operators with data name
		dataObject = DataObject.getInstance("sys_state_machine_detail");
		OrderBy orderBy = new OrderBy("parent_id");
		entitySet = dataObject.getTableEntitySet(orderBy);
		
		for (Entity entity: entitySet) {
			StatePoint statePoint = new StatePoint();
			statePoint.load(entity);
			
			ApproveRuntime approve = approveBucket.get(statePoint.getStepId());
			statePoint.setApproveFlow(approve);
			
			String machineId = entity.getString("parent_id");
			StateMachine machine = bucket.getCachedOne(machineId);
			
			if (machine == null) {
				logger.error("load state machine detail error, machine not exists: {}", machineId);
				continue;
			}			
			
			machine.loadOnePoint(statePoint);
			ObjectStateOperatorsBucket.loadOne(machine.getTargets(), statePoint);
		}
	}
	
	private void loadStateMessages(MachineBucket bucket) throws Exception {
		StateMessageBucket messageBucket = StateMessageBucket.getInstance();
		
		DataObject dataObject = DataObject.getInstance("sys_state_machine_target_error");
		EntitySet entitySet = dataObject.getTableEntitySet();
		
		for (Entity entity: entitySet) {
			StateMessage stateMessage = new StateMessage();
			stateMessage.load(entity);
			
			messageBucket.loadOne(stateMessage.createKey(), stateMessage);
		}
	}
	
	private void loadApproveStepBoard(MachineBucket bucket) throws Exception {
		StepBoardBucket boardBucket = StepBoardBucket.getInstance();
		StepBoard board;
		
		//1. 加载审批委员会/审批人
		DataObject dataObject = DataObject.getInstance("sys_state_board");
		EntitySet entitySet = dataObject.getTableEntitySet();
		
		for (Entity entity: entitySet) {
			board = new StepBoard();
			board.load(entity);
			
			boardBucket.loadOne(board.getId(), board);
		}
		
		//2. 加载委员会用户
		dataObject = DataObject.getInstance("sys_state_board_user");
		entitySet = dataObject.getTableEntitySet(new OrderBy("board_id"));
		
		for (Entity entity: entitySet) {
			StepUser stepUser = new StepUser();
			stepUser.load(entity);
			
			board = boardBucket.getCachedOne(stepUser.getBoardId());
			
			if (board == null) {
				logger.error("load step user error, board not exists: {}", stepUser.getBoardId());
				continue;
			}
			
			board.loadOneUser(stepUser.getId(), stepUser);
		}
	}
	
	public static void reloadStepBoard(String boardId) throws Exception {
		StepBoardBucket boardBucket = StepBoardBucket.getInstance();
		StepBoard board;
		
		//1. 加载审批委员会/审批人
		DataObject dataObject = DataObject.getInstance("sys_state_board");
		Entity boardEntity = dataObject.getTableEntity(boardId);
		
		if (boardEntity == null) {
			boardBucket.remove(boardId);
			return ;
		}
		
		board = new StepBoard();
		board.load(boardEntity);
		
		boardBucket.loadOne(board.getId(), board);
		
		//2. 加载委员会用户
		dataObject = DataObject.getInstance("sys_state_board_user");
		EntitySet entitySet = dataObject.getTableEntitySet(new Filter("board_id", boardId));
		
		for (Entity entity: entitySet) {
			StepUser stepUser = new StepUser();
			stepUser.load(entity);
			
			board = boardBucket.getCachedOne(stepUser.getBoardId());
			
			if (board == null) {
				logger.error("load step user error, board not exists: {}", stepUser.getBoardId());
				continue;
			}
			
			board.loadOneUser(stepUser.getId(), stepUser);
		}

		board.reWriterNames();
	}

	private void loadApproveFlow(MachineBucket bucket) throws Exception {
		ApproveRuntimeBucket stepsBucket = ApproveRuntimeBucket.getInstance();
		StepBoardBucket boardBucket = StepBoardBucket.getInstance();
		
		DataObject dataObject; EntitySet entitySet; 
		ApproveRuntime steps; Step step; StepBoard board;
		
		//1. 加载审批流
		dataObject = DataObject.getInstance("sys_state_approve");
		entitySet = dataObject.getTableEntitySet();
		
		for (Entity entity: entitySet) {
			steps = new ApproveRuntime();
			steps.load(entity);
			
			stepsBucket.loadOne(steps.getId(), steps);
		}
		
		//2. 加载审批流步骤
		dataObject = DataObject.getInstance("sys_state_approve_step");
		entitySet = dataObject.getTableEntitySet(new OrderBy("parent_id, index_no asc"));
		
		for (Entity entity: entitySet) {
			//2.1 加载步骤
			step = new Step();
			step.load(entity);
			
			//2.2 加载步骤审批委员会
			board = boardBucket.get(step.getBoardId());
			step.setBoard(board);
			
			//2.3 将步骤添加到 Steps 中
			steps = stepsBucket.getCachedOne(step.getParentId());
			
			if (steps == null) {
				logger.error("load step error, steps not exists: {}", step.getParentId());
				continue;
			}
			
			steps.loadOneStep(step);
		}
	}

	private void registerObjectActions(MachineBucket bucket) {
		StateCenter stateCenter = StateCenter.getInstance();
		WorkStep step = null; String toCode, endCode, operator;
		
		EventWorkSteps workSteps = new EventWorkSteps();
		
		for (StateMachine machine: bucket) {
			List<StatePoint> statePoints = machine.getStatePoints();
			List<String> targets = machine.getTargets();

			for (String target: targets) {
				for (StatePoint point: statePoints) {
					//1. 将【对象+方法】注册到 Action Dispatcher
					operator = point.getOperator();
					toCode = point.getToCode();
					step = new WorkStep(target, operator, operator, new Events(operator, toCode));
					WorkflowDispatcher.registerOneStep(step);
					
					if (Util.isEmpty(point.getStepId())) {
						stateCenter.loadOneTargetOperator(target, operator);
						continue;
					}
					//2. approve
					endCode = point.getEndCode();
					step = new WorkStep(target, "approve", "approve", new Events());
					workSteps.loadOne(step);
					
					//3. goBack
					endCode = point.getFromCode();
					step = new WorkStep(target, "goBack", "goBack", new Events("goBack", endCode, "stateFrom"));
					workSteps.loadOne(step);
					
					//3. goHome
					endCode = point.getFromCode();
					step = new WorkStep(target, "goHome", "goHome", new Events("goHome", endCode, "stateFrom"));
					workSteps.loadOne(step);
					
					//4. pullBack
					endCode = point.getFromCode();
					step = new WorkStep(target, "pullBack", "pullBack", new Events("pullBack", endCode, "stateFrom"));
					workSteps.loadOne(step);
					
					//5.
					stateCenter.loadOneTargetOperator(target, operator);
				}
				
				stateCenter.loadOneTargetOperator(target, "approve");
				stateCenter.loadOneTargetOperator(target, "goBack");
				stateCenter.loadOneTargetOperator(target, "goHome");
				stateCenter.loadOneTargetOperator(target, "pullBack");
			}
		}
		
		//
		for (WorkStep workStep: workSteps) {
			WorkflowDispatcher.registerOneStep(workStep);
		}
	}
	
	private void registerStateProvider(MachineBucket bucket) {
		StateCenter stateCenter = StateCenter.getInstance();
		WorkflowDispatcher.registerStateProvider(stateCenter, stateCenter.getTargetOperators());
	}

	private void registerStateDefaultValues(MachineBucket bucket) throws Exception {
		//1. 注册Default Value Creator
		FieldDefaultValueCreator.registerOne("state", StateDefaultValueCreator.class);

		//2. 为DataObject增加FieldRule
		for (StateMachine machine: bucket) {
			List<String> targets = machine.getTargets();
			StateField stateField = machine.getStateField();
			
			for (String target: targets) {
				DataObject dataObject = DataObject.getInstance(target);
				FieldsRuntime fieldsMeta = dataObject.getTableFieldMetas();
				FieldRules fieldRules = dataObject.getFieldRules();
				
				String fieldName = stateField.getCode();
				Field field = fieldsMeta.get(fieldName);
				
				StateDefaultValueCreator creator = new StateDefaultValueCreator();
				creator.setStateMachine(machine);
				
				FieldDefaultValueRule defaultValueRule = new FieldDefaultValueRule(field, creator, RuleSource.State);
				fieldRules.loadOne(fieldName, defaultValueRule);
			}
		}
	}
	
	public static ApproveTemplate loadOneApproveTemplate(String templateId) throws Exception {
		//1. 加载审批流模版
		DataObject dataObject = DataObject.getInstance("sys_state_approve");
		Entity entity = dataObject.getTableEntity(templateId);
		
		if (entity == null) {
			return null;
		}
		
		ApproveTemplate result = new ApproveTemplate();
		result.load(entity);
		
		//2. 加载审批流步骤
		dataObject = DataObject.getInstance("sys_state_approve_step");
		Filter filter = new Filter("parent_id", templateId);
		EntitySet entitySet = dataObject.getTableEntitySet(filter, new OrderBy("index_no asc"));
		
		for (Entity stepEntity: entitySet) {
			//2.1 加载步骤
			StepTemplate step = new StepTemplate();
			step.load(stepEntity);
			
			result.loadOneStep(step.getId(), step);
		}
		
		return result;
	}

	public static StatePoints loadPointsByApproveId(String templateId) throws Exception {
		DataObject dataObject = DataObject.getInstance("sys_state_machine_detail");
		EntitySet entitySet = dataObject.getTableEntitySet(new Filter("approve_id", templateId));
		
		StatePoints points = new StatePoints();
		MachineBucket bucket = MachineBucket.getInstance();
		StateMachine machine;
		
		for (Entity entity : entitySet) {
			StatePoint point= new StatePoint();
			point.load(entity);
			
			machine = bucket.get(entity.getString("parent_id"));
			point.setMachine(machine);
			
			points.add(point);
		}
		
		return points;
	}

	@Override
	public void shutDown() throws Exception {
		
	}


}