/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
*/
package org.apache.uima.ducc.jd;

import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.camel.CamelContext;
import org.apache.uima.ducc.common.NodeIdentity;
import org.apache.uima.ducc.common.component.AbstractDuccComponent;
import org.apache.uima.ducc.common.internationalization.Messages;
import org.apache.uima.ducc.common.jd.JdConstants;
import org.apache.uima.ducc.common.jd.files.WorkItemStateManager;
import org.apache.uima.ducc.common.utils.DuccLogger;
import org.apache.uima.ducc.common.utils.DuccLoggerComponents;
import org.apache.uima.ducc.common.utils.ExceptionHelper;
import org.apache.uima.ducc.common.utils.id.DuccId;
import org.apache.uima.ducc.transport.event.JdStateDuccEvent;
import org.apache.uima.ducc.transport.event.OrchestratorAbbreviatedStateDuccEvent;
import org.apache.uima.ducc.transport.event.common.DuccWorkJob;
import org.apache.uima.ducc.transport.event.common.DuccWorkMap;
import org.apache.uima.ducc.transport.event.common.IDuccProcess;
import org.apache.uima.ducc.transport.event.common.Rationale;
import org.apache.uima.ducc.transport.event.common.IDuccTypes.DuccType;
import org.apache.uima.ducc.transport.event.jd.DriverStatusReport;
import org.apache.uima.ducc.transport.event.jd.PerformanceSummaryWriter;
import org.apache.uima.ducc.transport.json.jp.JobProcessCollection;
import org.apache.uima.ducc.transport.json.jp.JobProcessData;


public class JobDriverComponent extends AbstractDuccComponent 
implements IJobDriverComponent {
	
	private static DuccLogger duccOut = DuccLoggerComponents.getJdOut(JobDriverComponent.class.getName());
	private static Messages duccMsg = JobDriverContext.getInstance().getSystemMessages();
	
	public JobDriverComponent(CamelContext context, String jdBrokerUrl, String jdQueuePrefix, String localeLanguage, String localeCountry) {
		super("JobDriver",context);
		
		init(jdBrokerUrl,jdQueuePrefix);
		JobDriverContext.getInstance().initSystemMessages(localeLanguage,localeCountry);
		duccMsg = JobDriverContext.getInstance().getSystemMessages();
	}
	
	private DuccId duccId = null;
	private String jobId = String.valueOf(-1);
	protected JobDriver thread = null;
	private String jdBrokerUrl;
	private String jdQueue;
	
	private AtomicInteger publicationCounter = new AtomicInteger(0);
	
	private JobProcessCollection jpc = null;
	
	private AtomicBoolean started = new AtomicBoolean(false);
	private AtomicBoolean active = new AtomicBoolean(true);

	private void init(String jdBrokerUrl,String jdQueuePrefix) {
		String methodName = "init";
		duccOut.trace(methodName, null, duccMsg.fetch("enter"));
		String jobIdProperty = System.getProperty(JdConstants.key_duccJobId);
		jobId = DuccWorkMap.normalize(jobIdProperty);
		this.jdBrokerUrl = jdBrokerUrl;
		this.jdQueue = jdQueuePrefix+jobId;
		duccOut.debug(methodName, null, duccMsg.fetchLabel("job.broker")+this.jdBrokerUrl+" "+duccMsg.fetchLabel("job.queue")+this.jdQueue);
		duccOut.trace(methodName, null, duccMsg.fetch("exit"));
	}
	public DuccLogger getLogger() {
	    return duccOut;
	  }
	private void dumpProcessMap(DuccWorkJob job) {
		String methodName = "pmap";
		if(job == null) {
			duccOut.debug(methodName, null, "job:"+job );
		}
		else {
			duccOut.debug(methodName, job.getDuccId(), "job:"+job.getId() );
			Map<DuccId, IDuccProcess> map = job.getProcessMap().getMap();
			for( Entry<DuccId, IDuccProcess> entry : map.entrySet() ) {
				IDuccProcess process = entry.getValue();
				process.getDuccId();
				NodeIdentity nodeIdentity = process.getNodeIdentity();
				String node = null;
				String ip = null;
				if(nodeIdentity != null) {
					node = nodeIdentity.getName();
					ip = nodeIdentity.getIp();
				}
				
				String pid = process.getPID();
				duccOut.debug(methodName, job.getDuccId(), process.getDuccId(), "node:"+node+" "+"ip:"+ip+" "+"pid:"+pid );
			}
		}
	}
	
	private boolean dumpProcessMapEnabled = false;
	
	protected String summarize(Exception e) {
		return ExceptionHelper.summarize(e);
	}
	
	protected void process(OrchestratorAbbreviatedStateDuccEvent duccEvent) {
		String methodName = "process";
		duccOut.trace(methodName, null, duccMsg.fetch("enter"));
		DuccWorkJob job = (DuccWorkJob) duccEvent.getWorkMap().findDuccWork(DuccType.Job, jobId);
		if(dumpProcessMapEnabled) {
			dumpProcessMap(job);
		}
		if(job != null) {
			if(duccId == null) {
				duccId = job.getDuccId();
			}
			duccOut.trace(methodName, duccId, "jd-cmd:"+job.getDriver().getCommandLine());
			duccOut.trace(methodName, duccId, "jp-cmd:"+job.getCommandLine());
			synchronized(jobId) {
				if(thread != null) {
					thread.setJob(job);
				}
				if(!started.get()) {
					started.set(true);
					duccOut.debug(methodName, job.getDuccId(), job.getJobState());
					duccOut.trace(methodName, job.getDuccId(), duccMsg.fetch("creating driver thread"));
					try {
						thread = new JobDriver();
						duccOut.trace(methodName, job.getDuccId(), "thread:"+thread);
						thread.initialize(job, getProcessJmxUrl());
						thread.start();
						jpc = new JobProcessCollection(job);
					}
					catch(Exception e) {
						duccOut.error(methodName, null, e);
						duccOut.error(methodName, job.getDuccId(), summarize(e), e);
					}
					catch(Throwable t) {
						duccOut.error(methodName, null, t);
					}
				}
				if(active.get()) {
					try {
						if(jpc != null) {
							ConcurrentSkipListMap<Long, JobProcessData> map = jpc.transform(job);
							jpc.exportData(map);
						}
					}
					catch(Exception e) {
						duccOut.error(methodName, job.getDuccId(), summarize(e), e);
					}
				}
			}
		}
		else {
			duccOut.debug(methodName, duccId, duccMsg.fetch("job not found"));
			if(active.get()) {
				active.set(false);
				if(thread != null) {
					thread.kill(new Rationale("job driver failed to locate job in map"));
					thread.interrupt();
					try {
						thread.join();
					} catch (InterruptedException e) {
						duccOut.debug(methodName, duccId, e);
					}
					duccOut.debug(methodName, duccId, duccMsg.fetch("thread killed"));
				}
			}
		}
		duccOut.trace(methodName, null, duccMsg.fetch("exit"));
	}
	
	protected void publisher() {
		String methodName = "publisher";
		PerformanceSummaryWriter performanceSummaryWriter = thread.getPerformanceSummaryWriter();
		if(performanceSummaryWriter == null) {
			duccOut.debug(methodName, null, duccMsg.fetch("performanceSummaryWriter is null"));
		}
		else {
			performanceSummaryWriter.writeSummary();
		}
		WorkItemStateManager workItemStateManager = thread.getWorkItemStateManager();
		if(workItemStateManager == null) {
			duccOut.debug(methodName, null, duccMsg.fetch("workItemStateManager is null"));
		}
		else {
			try {
				workItemStateManager.exportData();
			}
			catch(Exception e) {
				duccOut.error(methodName, null, e);
			}
			
		}
		
	}
	
	public JdStateDuccEvent getState() {
		String methodName = "getState";
		duccOut.trace(methodName, null, duccMsg.fetch("enter"));
		JdStateDuccEvent jdStateDuccEvent = new JdStateDuccEvent();
		if(active.get()) {
			publicationCounter.addAndGet(1);
			try {
				duccOut.debug(methodName, null, duccMsg.fetch("publishing state"));
				if(thread != null) {
					thread.rectifyStatus();
					DriverStatusReport dsr = thread.getDriverStatusReportCopy();
					if(dsr == null) {
						duccOut.debug(methodName, null, duccMsg.fetch("dsr is null"));
					}
					else {
						duccOut.debug(methodName, null, "driverState:"+dsr.getDriverState());
						duccOut.debug(methodName, dsr.getDuccId(), dsr.getLogReport());
						jdStateDuccEvent.setState(dsr);
					}
					publisher();
				}
				else {
					duccOut.debug(methodName, null, duccMsg.fetch("thread is null"));
				}
			}
			catch(Exception e) {
				duccOut.error(methodName, null, e);
			}
		}
		duccOut.trace(methodName, null, duccMsg.fetch("exit"));
		return jdStateDuccEvent;
	}
	
	public void evaluateJobDriverConstraints(OrchestratorAbbreviatedStateDuccEvent duccEvent) {
		String methodName = "evaluateDispatchedJobConstraints";
		duccOut.trace(methodName, null, duccMsg.fetch("enter"));
		duccOut.debug(methodName, null, duccMsg.fetchLabel("received")+"OrchestratorStateEvent");
		if(active.get()) {
			process(duccEvent);
		}
		duccOut.trace(methodName, null, duccMsg.fetch("exit"));
	}
	
}