/**
 * 
 */
package vn.mobileid.fms.client;

import java.util.UUID;
import java.util.concurrent.Callable;

import javax.jcr.Binary;
import javax.jcr.ItemExistsException;
import javax.jcr.Node;
import javax.jcr.Property;
import javax.jcr.RepositoryException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import vn.mobileid.fms.client.JCRManager.NodeUseInfo;


// TODO: Auto-generated Javadoc
/**
 * The Class JCRUploadTask.
 *
 * @author ThaoTruong
 * @created Oct 8, 2018
 */
public class JCRUploadTask implements Callable<JCRFile>{
	
	/** The Constant LOGGER. */
	static final Logger LOGGER = LoggerFactory.getLogger(JCRUploadTask.class);
	
	/** The jcr manager. */
	private JCRManager jcrManager;
	
	/** The jcr file. */
	private JCRFile jcrFile;
	
	/**
	 * The jcr file-response
	 */
	private JCRFile jcrFileResponse;
	
	/**
	 * Instantiates a new JCR upload task.
	 *
	 * @param jcrManager2 the jcr manager 2
	 * @param jcrFile2 the jcr file 2
	 */
	public JCRUploadTask(JCRManager jcrManager2, JCRFile jcrFile2) {		
		// TODO Auto-generated constructor stub
		this.jcrManager = jcrManager2;
		this.jcrFile = jcrFile2;
		this.jcrFileResponse = new JCRFile();
		
	}

	/* (non-Javadoc)
	 * @see java.util.concurrent.Callable#call()
	 */
	@Override
	public JCRFile call() throws Exception {
		// TODO Auto-generated method stub
		int retryCnt = 0;
		do {
			try {
				retryCnt++;
				return uploadJCR();
				
//			} catch (JCRException e) {
//				// TODO: handle exception
//
//				throw e;
			} catch (Exception e) {
				// TODO Auto-generated catch block
				LOGGER.error("Retry/max: {}/{}. Fail to upload file {} into folder {}, caused by ", retryCnt, jcrManager.retryUpload, jcrFile.getFilePath(), jcrFileResponse.getFolderName(), e);
				if(retryCnt > jcrManager.retryUpload) {
					throw e;
				}				
			}
		} while (true);
	}
	
	/**
	 * Upload JCR.
	 *
	 * @return the JCR file
	 * @throws Exception 
	 */
	public JCRFile uploadJCR() throws Exception {			
		//Node session = jcrManager.getSession(Thread.currentThread().getName());
		//RepositoryInfo rpInfo = jcrManager.getNodeToUpload(Thread.currentThread().getName());		
		Thread thread = Thread.currentThread();
		
		String tName = thread.getName();
		NodeUseInfo nodeUseInfo = jcrManager.getNodeToUpload(tName);
		Node folder = nodeUseInfo.getNode();
		jcrFileResponse.setFolderName(folder.getName());
		//LOGGER.info("Thread {} upload to JCR: [Node Name: {}]", tName, folder.getName()); 			
		
		//Node content = JcrUtils.putFile(folder, jcrFile.getFilePath(), jcrFile.getMimeType(), jcrFile.getStream());
		//folder.getSession().save();
		
		String fileName = tName.split("-")[2].concat("_").concat(jcrFile.getFilePath() == null ? UUID.randomUUID().toString() : jcrFile.getFilePath());
		
        Node file = folder.addNode(fileName, "nt:file");
        Binary binary = file.getSession().getValueFactory().createBinary(jcrFile.getStream());
        
		//Node file = addFile(folder);		
        Node content = addContent(file, binary, jcrFile.getMimeType());
        
        try {
        	folder.getSession().save();
        }catch (ItemExistsException e) {
			// TODO: handle exception
        	LOGGER.warn("==> FAIL to save file [{}], caused by {}, refresh to load", jcrFileResponse.getFileName(), e.getMessage());
        	folder.refresh(true);
        	//file = addFile(folder); 
        	file = folder.addNode(jcrFile.getFilePath(), "nt:file");
        	content = addContent(file, binary, jcrFile.getMimeType());        
            folder.getSession().save();
		}
           
        //LOGGER.info("Upload is successful, upload file [{}] to folder [{}]", jcrFileResponse.getFileName(), jcrFileResponse.getFolderName());
        //jcrFileResponse.setFilePath(nodeUseInfo.uri.concat("/").concat(jcrFileResponse.getFolderName()).concat("/").concat(jcrFileResponse.getFileName()));       
        
		try {
			jcrFileResponse.setUuid(content.getProperty(Property.JCR_UUID).getString());
			jcrFileResponse.setMimeType(content.getProperty(Property.JCR_MIMETYPE).getString());
			jcrFileResponse.setLastModified(content.getProperty(Property.JCR_LAST_MODIFIED).getString());
			jcrFileResponse.setLastModifiedBy(content.getProperty(Property.JCR_LAST_MODIFIED_BY).getString());
						
			String path = content.getPath();
			String[] paths = content.getPath().split("/"); 
			jcrFileResponse.setFileName(paths[2]);        
	        jcrFileResponse.setFolderName(paths[1]);    
	        jcrFileResponse.setFilePath(nodeUseInfo.getUri().concat("/").concat(paths[1]).concat("/").concat(paths[2]));	        
	        //jcrFileResponse.setFilePath(nodeUseInfo.uri.concat("/").concat(jcrFileResponse.getFolderName()).concat("/").concat(jcrFileResponse.getFileName()));        
	        //LOGGER.info("Upload is successful, upload file [{}] to folder [{}]", jcrFileResponse.getFileName(), jcrFileResponse.getFolderName());
	        LOGGER.info("Upload is successful, uuid [{}] path [{}]", jcrFileResponse.getUuid(), path);
		} catch (RepositoryException e) {
			// TODO: handle exception
			LOGGER.warn("==> FAIL to get content file [{}], caused by {}, sleep for sync and switch to another session", jcrFile.getFilePath(), e.getMessage());
			//Thread.sleep(jcrManager.timeoutSync * 1000);
			//Session session = jcrManager.getSession();			
        	//content = session.getNode("/".concat(jcrFileResponse.getFolderName()).concat("/").concat(jcrFileResponse.getFileName()).concat("/jcr:content"));
        	//content = jcrManager.getJCRFile("/".concat(jcrFileResponse.getFolderName()).concat("/").concat(jcrFileResponse.getFileName()).concat("/jcr:content"));
			folder.refresh(true);
			
			jcrFileResponse.setUuid(content.getProperty(Property.JCR_UUID).getString());
			jcrFileResponse.setMimeType(content.getProperty(Property.JCR_MIMETYPE).getString());
			jcrFileResponse.setLastModified(content.getProperty(Property.JCR_LAST_MODIFIED).getString());
			jcrFileResponse.setLastModifiedBy(content.getProperty(Property.JCR_LAST_MODIFIED_BY).getString());
			
			String[] path = content.getPath().split("/"); 
			jcrFileResponse.setFileName(path[2]);        
	        jcrFileResponse.setFolderName(path[1]);    
	        jcrFileResponse.setFilePath(nodeUseInfo.getUri().concat("/").concat(path[1]).concat("/").concat(path[2]));	        
	        //jcrFileResponse.setFilePath(nodeUseInfo.uri.concat("/").concat(jcrFileResponse.getFolderName()).concat("/").concat(jcrFileResponse.getFileName()));        
	        //LOGGER.info("Upload is successful, upload file [{}] to folder [{}]", jcrFileResponse.getFileName(), jcrFileResponse.getFolderName());
	        LOGGER.info("Upload is successful, uuid [{}] path [{}]", jcrFileResponse.getUuid(), path);
		}
        
//        LOGGER.info("=======Props of content: =======");
//        PropertyIterator props = content.getProperties();
//		while (props.hasNext()) {
//			Property prop = props.nextProperty();
//			if (!prop.getName().equals("jcr:data"))
//				LOGGER.info(prop.getName() + ": " + prop.getString());
//		}
//		
//		LOGGER.info("=======Props of file: =======");
//		props = file.getProperties();
//		while (props.hasNext()) {
//			Property prop = props.nextProperty();
//			if (!prop.getName().equals("jcr:data"))
//				LOGGER.info(prop.getName() + ": " + prop.getString());
//		}
//		
//		LOGGER.info("=======Props of folder: =======");
//		props = folder.getProperties();
//		while (props.hasNext()) {
//			Property prop = props.nextProperty();
//			if (!prop.getName().equals("jcr:data"))
//				LOGGER.info(prop.getName() + ": " + prop.getString());
//		}
//		
//		LOGGER.info("=======Props of root: =======");
//		props = folder.getParent().getProperties();
//		while (props.hasNext()) {
//			Property prop = props.nextProperty();
//			if (!prop.getName().equals("jcr:data"))
//				LOGGER.info(prop.getName() + ": " + prop.getString());
//		}
		
//        Iterator<Property> props = JcrUtils.getProperties(content).iterator();
//        while (props.hasNext()) {
//			Property prop = props.next();
//			if (!prop.getName().equals(Property.JCR_DATA))
//				LOGGER.info(prop.getName() + ": " + prop.getValue().getString());
//		}
//        
//        Repository repository = folder.getSession().getRepository();
//        
//        for(String key : repository.getDescriptorKeys()) {
//        	LOGGER.info(key + ": " + repository.getDescriptorValue(key).getString());
//        }
        
        
//        try {
//        	String path = file.getPath();
//        	JcrUtils.getProperties(content);
//        	
//        }catch (RepositoryException e) {
//			// TODO: handle exception
//        	folder = jcrManager.getNodeToUpload(tName).getNode();
//        	content.getProperties();        	
//		}
//        
//        JCRFile referFile = new JCRFile();
//        String[] path = content.getPath().split("/"); 
//        referFile.setFileName(path[2]);        
//        referFile.setFolderName(path[1]);    
//        referFile.setFilePath(nodeUseInfo.uri.concat("/").concat(path[1]).concat("/").concat(path[2]));
//        
//        referFile.setUuid(content.getProperty(Property.JCR_UUID).getString());
//        referFile.setMimeType(content.getProperty(Property.JCR_MIMETYPE).getString());
//        referFile.setLastModified(content.getProperty(Property.JCR_LAST_MODIFIED).getString());
//        referFile.setLastModifiedBy(content.getProperty(Property.JCR_LAST_MODIFIED_BY).getString());
        
        return jcrFileResponse;
    }	
	
//	private Node addFile(Node parent) throws ItemExistsException, PathNotFoundException, NoSuchNodeTypeException, LockException, VersionException, ConstraintViolationException, RepositoryException {		
//		// last path element (path = leaf node name)
//		String fileName = jcrFile.getFilePath();
//		
//		String leafNodeName;
//		Node file;
//		leafNodeName = fileName; 
//        if (!parent.hasNode(fileName)) {
//        	leafNodeName = fileName;     	
//        } else {
//            // leaf node already exists, create new unique name
//            int i = 0;
//            int lastDot = fileName.lastIndexOf(".");
//            String name = fileName.substring(0, lastDot);
//            String ext = fileName.substring(lastDot, fileName.length());
//            do {
//                leafNodeName = name + "_" + String.valueOf(i) + ext;
//                i++;
//            } while (parent.hasNode(leafNodeName));
//            LOGGER.warn("{} is existed, change filename to {}", fileName, leafNodeName);
//        }
//        
//        file = parent.addNode(leafNodeName, "nt:file");
//        jcrFileResponse.setFileName(leafNodeName);
//               
//        //String[] path = file.getPath().split("/"); 
//        //jcrFileResponse.setFileName(path[2]);        
//        //jcrFileResponse.setFolderName(path[1]);    
//        
//        return file;
//	}
	
	//private Binary binary;
		private static Node addContent(Node file, Binary stream, String mime) throws Exception {
			Node content = file.addNode(Property.JCR_CONTENT, "nt:resource");
//			if (binary == null) {
//				binary = file.getSession().getValueFactory().createBinary(jcrFile.getStream()); // session.getValueFactory().createBinary(jcrFile.getStream());
//			}		
//			Binary binary = file.getSession().getValueFactory().createBinary(stream);
			content.setProperty(Property.JCR_DATA, stream);
			// content.setProperty(Property.JCR_DATA, jcrFile.getStream());
			content.setProperty(Property.JCR_MIMETYPE, mime);		
			return content;
		}
}