package th.co.ais.ssbsrfc.instance;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import th.co.ais.ssbsrfc.config.Invoke;
import th.co.ais.ssbsrfc.config.StateConfig;
import th.co.ais.ssbsrfc.interfaces.EQXMsg;
import th.co.ais.ssbsrfc.utils.Global;
import th.co.ais.ssbsrfc.utils.Log;
import ais.mmt.sand.comlog.DetailsLogPrototype;
import ais.mmt.sand.comlog.SummaryLogPrototype;
import ec02.utils.AppLog;

public class AFInstance {
	
	private int gDialogueId = -1;
	private ArrayList<FMInstance> listFlow;
	private Map<String, FMInstance> dicInvoke; 
	private ArrayList<Timeout> globalListTimeout;
	// managetimeout
	private ArrayList<Timeout> listTimeout;
	private int flow = 0;
	private ArrayList<Object> input = null; /** Detail Log Input **/
	private ArrayList<Object> output = null; /** Detail Log Output **/
	private ArrayList<Stat> listStat;
	private ArrayList<String> listConditionStat;
	private SummaryLogPrototype sumlog = null; /** Summary Log **/
	private DetailsLogPrototype detaillog = null; /** Detail Log **/
	private BackupSummary backupSummary = null;
	private Map<String, String> mapHttpData = null;
	private HashMap<String, Response> listOrig;
	private String orig = null;
	private String invoke = null;
	private String currentState = StateConfig.SSTATE_END;
	private String previousState = StateConfig.SSTATE_BEGIN;
	private String outgoingStateTimeStamp = null;
	private String startFlowTimeStamp = null;
	private String initialInvoke = null;
	private String resultCode = null;
	private String resultDescription = null;
	private String responseTime = null;
	private String processingTime = null;
	private String acknowledgeTime = null;
	private String dialogueId = null;
	private Map<String, RetryIns> dicRetry = null;
	
	private AdjustmentRequestIns adjustmentRequestIns = null;
	
	public AdjustmentRequestIns getAdjustmentRequestIns() {
		return adjustmentRequestIns;
	}
	public void setAdjustmentRequestIns(AdjustmentRequestIns adjustmentRequestIns) {
		this.adjustmentRequestIns = adjustmentRequestIns;
	}
	public String getOrig() {
		return orig;
	}
	public void setOrig(String orig) {
		this.orig = orig;
	}
	public String getInvoke() {
		return invoke;
	}
	public void setInvoke(String invoke) {
		this.invoke = invoke;
	}
	public String getCurrentState() {
		return currentState;
	}
	public void setCurrentState(String currentState) {
		if (this.currentState.equals(StateConfig.SSTATE_END)) {
			this.setPreviousState(StateConfig.SSTATE_BEGIN);
		} else if (!this.currentState.equals(currentState)) {
			this.setPreviousState(this.currentState);
		}
		this.currentState = currentState;
	}
	public String getPreviousState() {
		return previousState;
	}
	public void setPreviousState(String previousState) {
		this.previousState = previousState;
	}
	public Map<String, String> getMapHttpData() {
		if (mapHttpData == null) {
			mapHttpData = new HashMap<String, String>(); 
		}
		return mapHttpData;
	}
	
	public void setMapHttpData(Map<String, String> mapHttpData) {
		this.mapHttpData = mapHttpData;
	}
	public HashMap<String, Response> getListOrig() {
		if (listOrig == null) {
			listOrig = new HashMap<String, Response>();
		}
		return listOrig;
	}
	
	public void setListOrig(HashMap<String, Response> listOrig) {
		this.listOrig = listOrig;
	}
	
	public void setListOrigKey(String key, Response value) {
		this.listOrig.put(key, value);
	}
	
	public Response getListOrigForKey(String key) {
		return listOrig.get(key);
	}
	
	public void setListOrigKeyRemove(String key) {
		this.listOrig.remove(key);
	}
	
	public int getFlow() {
		return flow;
	}
	public void setFlow(int flow) {
		if (this.flow == 0) {
			this.flow = flow;
			Global.flow = flow;
		}
	}
	public void setForceFlow(int flow) {
		this.flow = flow;
	}
	public void clearFlow()
	{
		this.flow = 0;
	}
	public ArrayList<Timeout> getListTimeout() {
		if (listTimeout == null) {
			listTimeout = new ArrayList<Timeout>();
		}
		return listTimeout;
	}
	public void setListTimeout(ArrayList<Timeout> listTimeout) {
		this.listTimeout = listTimeout;
	}
	public void listTimeoutRemove(String name) {
		ArrayList<Timeout> lTimeout = this.getListTimeout();
		for (Timeout timeout : lTimeout) {
			if (timeout.getName() != null && timeout.getName().equals(name)) {
				this.getListTimeout().remove(timeout);
				break;
			}
		}
		// check remove all for eventType
		listTimeoutRemoveForEventType(new Invoke(name).eventType);
	}
	public void listTimeoutRemoveForEventType(String _eventType) {
		ArrayList<Timeout> lTimeout = new ArrayList<Timeout>();
		for (Timeout timeout : this.getListTimeout()) {
			if (timeout.getName() != null & timeout.getName().contains(".")) {
				String eventType = new Invoke(timeout.getName()).eventType;
				if (eventType.equals(_eventType)) {
					lTimeout.add(timeout);
				}
			}
		}
		for (Timeout timeout : lTimeout) {
			this.getListTimeout().remove(timeout);
			if (Log.debug) {
				AppLog.d("## RM TIMEOUT :" + timeout.getName());
			}
		}
	}
	
	public boolean isTimeoutFotEventType(String _eventType) {
		boolean isTrue = false;
		for (Timeout timeout : this.getListTimeout()) {
			if (timeout.getName() != null & timeout.getName().contains(".")) {
				String eventType = new Invoke(timeout.getName()).eventType;
				if (eventType.equals(_eventType)) {
					isTrue = true;
				}
			}
		}
		return isTrue;
	}
	
	public ArrayList<Timeout> getGlobalListTimeout() {
		return globalListTimeout;
	}
	public void setGlobalListTimeout(ArrayList<Timeout> globalListTimeout) {
		this.globalListTimeout = globalListTimeout;
	}
	public String getOutgoingStateTimeStamp() {
		return outgoingStateTimeStamp;
	}
	public void setOutgoingStateTimeStamp(String outgoingStateTimeStamp) {
		this.outgoingStateTimeStamp = outgoingStateTimeStamp;
	}
	public String getInitialInvoke() {
		return initialInvoke;
	}
	public void setInitialInvoke(String initialInvoke) {
		if (this.initialInvoke == null) {
			this.initialInvoke = initialInvoke;
		}
	}
	public void setForceInitialInvoke(String initialInvoke) {
		this.initialInvoke = initialInvoke;
	}
	public void clearInitialInvoke() {
		this.initialInvoke = null;
	}
	public String getStartFlowTimeStamp() {
		return startFlowTimeStamp;
	}
	public void setStartFlowTimeStamp(String startFlowTimeStamp) {
		this.startFlowTimeStamp = startFlowTimeStamp;
	}
	public String getResultCode() {
		String tmp = resultCode;
		if (resultCode == null || resultCode.equals(EQXMsg.EMPTY)) {
			tmp = "null";
		}
		return tmp;
	}
	public void setResultCode(String resultCode) {
		if (resultCode != null && !resultCode.equals("null")) {
			this.resultCode = resultCode;
		}
	}
	public String getResultDescription() {
		String tmp = resultDescription;
		if (resultDescription == null || resultDescription.equals(EQXMsg.EMPTY)) {
			tmp = "null";
		}
		return tmp;
	}
	public void setResultDescription(String resultDescription) {
		if (resultDescription != null && !resultDescription.equals("null")) {
			this.resultDescription = resultDescription;
		}
	}
	public void setStartFlowTimeStampForEmpty() {
		long currentDateTime = System.currentTimeMillis();
		String timeStamp = Global.getTimeStampLog(currentDateTime);
		if (this.startFlowTimeStamp == null) {
			this.startFlowTimeStamp = timeStamp;
			Global.currentInputDateTime = currentDateTime;
		}
		this.setInputTimeStamp(timeStamp);
	}
	public void setInputTimeStamp(String inputTimeStamp) {
		boolean bool = 	this.isOutgoingStateTimeStamp();
		if (bool) {
			long responseTime = 0;
			try {
				String input = this.getOutgoingStateTimeStamp();
				String output = inputTimeStamp;
				responseTime = Global.diffTimeStampLog(input, output);
			} catch (Exception e) {
				responseTime = 0;
			}
			this.setResponseTime("" + responseTime);
		}
		Global.inputTimeStamp = inputTimeStamp;
	}
	public boolean isOutgoingStateTimeStamp() {
		boolean bool = false;
		if (this.outgoingStateTimeStamp != null) {
			bool = true;
		}
		return bool;
	}
	public String getResponseTime() {
		return responseTime;
	}
	public void setResponseTime(String responseTime) {
		this.responseTime = responseTime;
	}
	public String getProcessingTime() {
		return processingTime;
	}
	public void setProcessingTime(String processingTime) {
		this.processingTime = processingTime;
	}
	public String getAcknowledgeTime() {
		return acknowledgeTime;
	}
	public void setAcknowledgeTime(String acknowledgeTime) {
		this.acknowledgeTime = acknowledgeTime;
	}
	public void putInput(Object input) {
		if (this.input == null) {
			this.input = new ArrayList<Object>(); 
		}
		this.input.add(input);
	}
	public void putOutput(Object output) {
		if (this.output == null) {
			this.output = new ArrayList<Object>(); 
		}
		this.output.add(output);
	}
	
	public ArrayList<Object> getInput() {
		return input;
	}
	public void setInput(ArrayList<Object> input) {
		this.input = input;
	}
	public ArrayList<Object> getOutput() {
		return output;
	}
	public void setOutput(ArrayList<Object> output) {
		this.output = output;
	}
	public ArrayList<Stat> getListStat() {
		if (this.listStat == null) {
			this.listStat = new ArrayList<Stat>();
		}
		return listStat;
	}
	public void setListStat(ArrayList<Stat> listStat) {
		this.listStat = listStat;
	}
	public ArrayList<FMInstance> getListFlow() {
		if (listFlow == null) {
			listFlow = new ArrayList<FMInstance>();
		}
		return listFlow;
	}
	public void setListFlow(ArrayList<FMInstance> listFlow) {
		this.listFlow = listFlow;
	}
	public void putListFlow(FMInstance ins)
	{
		this.listFlow.add(ins);
	}
	public void removeListFlow(FMInstance ins)
	{
		this.listFlow.remove(ins);
	}
	public Map<String, FMInstance> getDicInvoke() {
		if (dicInvoke == null) {
			dicInvoke = new LinkedHashMap<String, FMInstance>();
		}
		return dicInvoke;
	}
	public void setDicInvoke(Map<String, FMInstance> dicInvoke) {
		this.dicInvoke = dicInvoke;
	}
	public void putDicInvoke(String key, FMInstance value)
	{
		this.getDicInvoke().put(key, value);
	}
	public SummaryLogPrototype getSumlog() {
		if (sumlog == null) {
			sumlog = SummaryLogPrototype.getInstance(StateConfig.PROJECT_NAME);
		}
		return sumlog;
	}
	public void setSumlog(SummaryLogPrototype sumlog) {
		this.sumlog = sumlog;
	}
	public DetailsLogPrototype getDetaillog() {
		if (detaillog == null) {
			detaillog = DetailsLogPrototype.getInstance(StateConfig.PROJECT_NAME);
		}
		return detaillog;
	}
	public void setDetaillog(DetailsLogPrototype detaillog) {
		this.detaillog = detaillog;
	}
	public BackupSummary getBackupSummary() {
		if (this.backupSummary == null) {
			this.backupSummary = new BackupSummary();
		}
		return backupSummary;
	}
	public void setBackupSummary(BackupSummary backupSummary) {
		this.backupSummary = backupSummary;
	}
	public String getDialogueId() {
		if(this.gDialogueId == -1) {
			this.gDialogueId = Global.minDialogueId;
		}
		this.dialogueId = String.format("%02d", this.gDialogueId);
		this.gDialogueId++;
		if(this.gDialogueId == Global.maxDialogueId + 1) {
			this.gDialogueId = Global.minDialogueId;
		}
		return dialogueId;
	}
	public String getDialogueIdForMultiFlow() {
		return dialogueId;
	}
	public void setDialogueId(String dialogueId) {
		this.dialogueId = dialogueId;
	}
	public int getGlobalDialogueId() {
		return this.gDialogueId;
	}
	public void setGlobalDialogueId(int globalDialogueId) {
		this.gDialogueId = globalDialogueId;
	}
	public ArrayList<String> getListConditionStat() {
		if (this.listConditionStat == null) {
			this.listConditionStat = new ArrayList<String>();
		}
		return this.listConditionStat;
	}
	public void setListConditionStat(ArrayList<String> listConditionStat) {
		this.listConditionStat = listConditionStat;
	}
	public Map<String, RetryIns> getDicRetry() {
		if (this.dicRetry == null) {
			this.dicRetry = new LinkedHashMap<String, RetryIns>(); 
		}
		return this.dicRetry;
	}
	public void setDicRetry(Map<String, RetryIns> dicRetry) {
		this.dicRetry = dicRetry;
	}
}