package org.argeo.slc.jsch;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.PathMatcher;
import org.springframework.util.StringUtils;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.Session;

public class ScpTo extends AbstractJschTask {
	private final static Log log = LogFactory.getLog(ScpTo.class);

	private Resource localResource;
	private String remotePath;

	private String dir;
	private String remoteDir;
	private List<String> includes = new ArrayList<String>();

	private List<String> excludes = new ArrayList<String>();

	private PathMatcher pathMatcher;

	public void run(Session session) {
		if (StringUtils.hasText(dir)) {
			if (!StringUtils.hasText(remoteDir))
				throw new SlcException("Remote dir has to be specified.");

			String dirOs = dir.replace('/', File.separatorChar);
			if (dirOs.charAt(dir.length() - 1) != File.separatorChar) {
				dirOs = dirOs + File.separator;
			}

			if (pathMatcher == null)
				pathMatcher = new AntPathMatcher();

			log.info("Start multiple scp based on " + dirOs);
			scanDir(session, dirOs, "", includes, excludes);
		}

		if (localResource != null) {
			uploadResource(session, localResource);
		}
	}

	protected void scanDir(Session session, String dir, String currentRelPath,
			List<String> includes, List<String> excludes) {
		File[] files = new File(dir).listFiles();
		for (File file : files) {
			if (!file.isDirectory()) {
				String relPath = currentRelPath.concat(file.getName());
				if (match(relPath, includes, excludes, false)) {
					uploadFile(session, file, remoteDir + '/' + relPath);
				}
			} else {
				String relPath = currentRelPath.concat(file.getName()).concat(
						"/");
				if (match(relPath, includes, excludes, true)) {
					String nextDir = dir.concat(file.getName()).concat(
							File.separator);
					scanDir(session, nextDir, relPath, includes, excludes);
				}
			}
		}
	}

	protected Boolean match(String path, List<String> includes,
			List<String> excludes, boolean matchStart) {
		for (String patternIn : includes) {
			boolean matchIn = matchStart ? pathMatcher.matchStart(patternIn,
					path) : pathMatcher.match(patternIn, path);
			if (matchIn) {
				// Could be included, check excludes
				boolean excluded = false;
				ex: for (String patternEx : excludes) {
					boolean matchEx = matchStart ? pathMatcher.matchStart(
							patternEx, path) : pathMatcher.match(patternEx,
							path);

					if (matchEx) {
						excluded = true;
						break ex;
					}
				}
				if (!excluded)
					return true;
			}
		}
		return false;
	}

	protected void uploadFile(Session session, File file, String remoteFile) {
		try {
			upload(session, new FileInputStream(file), file.length(), file
					.getPath(), file.toString(), remoteFile);
		} catch (FileNotFoundException e) {
			throw new SlcException("Cannot upload " + file, e);
		}
	}

	protected void uploadResource(Session session, Resource resource) {
		String targetPath = remotePath != null ? remotePath : remoteDir + '/'
				+ resource.getFilename();
		try {
			File lFile = resource.getFile();
			uploadFile(session, lFile, targetPath);
		} catch (IOException e) {
			// no underlying file found
			// load the resource in memory before transferring it
			InputStream in = null;
			try {
				byte[] arr;
				String path;
				if (resource instanceof ByteArrayResource) {
					arr = ((ByteArrayResource) resource).getByteArray();
					path = "bytearray";
				} else {
					in = resource.getInputStream();
					ByteArrayOutputStream out = new ByteArrayOutputStream();
					IOUtils.copy(in, out);
					arr = out.toByteArray();
					path = resource.getURL().getPath();
					if (path.startsWith("/"))
						path = path.substring(1);
				}
				ByteArrayInputStream content = new ByteArrayInputStream(arr);
				upload(session, content, arr.length, path, resource.toString(),
						targetPath);
				arr = null;
			} catch (IOException e1) {
				throw new SlcException("Can not interpret resource "
						+ localResource, e1);
			} finally {
				IOUtils.closeQuietly(in);
				// no need to close byte arrays streams
			}
		}
	}

	protected void upload(Session session, InputStream in, long size,
			String path, String sourceDesc, String remoteFile) {
		OutputStream channelOut;
		InputStream channelIn;
		try {

			// exec 'scp -t rfile' remotely
			String command = "scp -p -t " + remoteFile;
			Channel channel = session.openChannel("exec");
			((ChannelExec) channel).setCommand(command);

			// get I/O streams for remote scp
			channelOut = channel.getOutputStream();
			channelIn = channel.getInputStream();

			channel.connect();
			checkAck(channelIn);

			// send "C0644 filesize filename", where filename should not include
			// '/'
			long filesize = size;
			command = "C0644 " + filesize + " ";
			int index = path.lastIndexOf('/');
			if (index > 0) {
				command += path.substring(index + 1);
			} else {
				command += path;
			}
			command += "\n";

			channelOut.write(command.getBytes());
			channelOut.flush();
			checkAck(channelIn);

			if (log.isTraceEnabled())
				log.debug("Start copy of " + sourceDesc + " to " + remoteFile
						+ " on " + getSshTarget() + "...");

			final long oneMB = 1024l;// in KB
			final long tenMB = 10 * oneMB;// in KB

			// send a content of lfile
			byte[] buf = new byte[1024];
			long cycleCount = 0;
			long nbrOfBytes = 0;
			while (true) {
				int len = in.read(buf, 0, buf.length);
				if (len <= 0)
					break;
				channelOut.write(buf, 0, len); // out.flush();
				nbrOfBytes = nbrOfBytes + len;
				if (((cycleCount % oneMB) == 0) && cycleCount != 0)// each 1 MB
					System.out.print('#');
				if (((cycleCount % (tenMB)) == 0) && cycleCount != 0)// each 10
					// MB
					System.out.print(" - " + cycleCount / tenMB + "0 MB\n");
				cycleCount++;
			}
			// send '\0'
			buf[0] = 0;
			channelOut.write(buf, 0, 1);
			channelOut.flush();
			checkAck(channelIn);

			if (log.isDebugEnabled())
				log.debug("Transferred to " + remoteFile + " ("
						+ sizeDesc(nbrOfBytes) + ") on " + getSshTarget()
						+ " from " + sourceDesc);

			IOUtils.closeQuietly(channelOut);

			channel.disconnect();
		} catch (Exception e) {
			throw new SlcException("Cannot copy " + path + " to " + remoteFile,
					e);
		} finally {
			IOUtils.closeQuietly(in);
		}
	}

	protected String sizeDesc(Long nbrOfBytes) {
		if (nbrOfBytes < 1024)
			return nbrOfBytes + " B";
		else if (nbrOfBytes < 1024 * 1024)
			return (nbrOfBytes / 1024) + " KB";
		else
			return nbrOfBytes / (1024 * 1024) + " MB";
	}

	public void setLocalResource(Resource localFile) {
		this.localResource = localFile;
	}

	public void setRemotePath(String remoteFile) {
		this.remotePath = remoteFile;
	}

	public void setDir(String dir) {
		this.dir = dir;
	}

	public void setRemoteDir(String remoteDir) {
		this.remoteDir = remoteDir;
	}

	public void setIncludes(List<String> includes) {
		this.includes = includes;
	}

	public void setExcludes(List<String> excludes) {
		this.excludes = excludes;
	}

	public void setPathMatcher(PathMatcher pathMatcher) {
		this.pathMatcher = pathMatcher;
	}

}