package de.hftstuttgart.dtabackend.utils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.eclipse.jgit.api.CloneCommand;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
import org.springframework.stereotype.Component;
import org.springframework.util.FileSystemUtils;
import org.tmatesoft.svn.core.SVNDepth;
import org.tmatesoft.svn.core.SVNException;
import org.tmatesoft.svn.core.SVNURL;
import org.tmatesoft.svn.core.auth.BasicAuthenticationManager;
import org.tmatesoft.svn.core.auth.ISVNAuthenticationManager;
import org.tmatesoft.svn.core.io.SVNRepository;
import org.tmatesoft.svn.core.io.SVNRepositoryFactory;
import org.tmatesoft.svn.core.wc.SVNUpdateClient;
import org.tmatesoft.svn.core.wc.SVNWCUtil;
import org.tmatesoft.svn.core.wc2.SvnCheckout;
import org.tmatesoft.svn.core.wc2.SvnOperationFactory;
import org.tmatesoft.svn.core.wc2.SvnTarget;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.regex.Matcher;

@Component
public class RepoUtil {

    private static final Logger LOG = LogManager.getLogger(RepoUtil.class);

    public RepoUtil() {}

    public void cloneRepository(Matcher config, String targetPath, String subDir) {
        LOG.debug(String.format("cloning repository: %s", config.group(1)));

        File targetDirectory = new File(targetPath);
        if (targetDirectory.exists()) {
            LOG.debug("clone target directory existing yet, deleting now");
            FileSystemUtils.deleteRecursively(targetDirectory);
        }

        File checkoutDirectory = targetDirectory;
        //if an optional directory parameter was given
        if(subDir!="")
        {
        	//create companion checkout dir "targetPath"+"_checkout"
            checkoutDirectory = new File(targetPath+"_checkout");
            if (checkoutDirectory.exists()) {
            	LOG.debug("clone checkout directory existing yet, deleting now");
            	FileSystemUtils.deleteRecursively(checkoutDirectory);
            }
        }
        
        try {
        	LOG.debug("preparing clone");

        	if (config.group(1).endsWith(".git")) {
	            CloneCommand cloneCommand = Git.cloneRepository()
	                .setDirectory(checkoutDirectory)
	                .setURI(config.group(1));
	
	            if (!config.group(2).equals("none") && !config.group(3).equals("none")) {
	                LOG.debug("setting credentials");
	                cloneCommand.setCredentialsProvider(new UsernamePasswordCredentialsProvider(config.group(2), config.group(3)));
	            }
	
	            LOG.debug("cloning...");
	            cloneCommand.call().close();
        	}
        	else {
        		URL sourceUrl=new URL(config.group(1));
                SVNURL url = SVNURL.create(sourceUrl.getProtocol(), null, sourceUrl.getHost(), sourceUrl.getPort(), sourceUrl.getPath(), false);
                SvnOperationFactory operationFactory = new SvnOperationFactory();
                SvnCheckout checkout = operationFactory.createCheckout();
                checkout.setSingleTarget(SvnTarget.fromFile(new File(targetPath)));
                checkout.setSource(SvnTarget.fromURL(url));
                
                String protocol = url.getProtocol();

                if (!config.group(2).equals("none") && !config.group(3).equals("none")) {
                	if (protocol.equals("https")) {
                		LOG.debug("Setting SVN credentials for HTTPS checkout with username/password");
                		operationFactory.setAuthenticationManager(new BasicAuthenticationManager(config.group(2), config.group(3)));
                	}
                	else if (protocol.equals("svn+ssh")) {
                		LOG.debug("Setting credentials for SVN+SSH Authentication with username/password");
                		//ISVNAuthenticationManager authManager = new BasicAuthenticationManager(new SVNAuthentication[] { new SVNSSHAuthentication(username, password, -1, false)});//SVNWCUtil.createDefaultAuthenticationManager(username, password); 
                		ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(config.group(2), config.group(3).toCharArray());
                		operationFactory.setAuthenticationManager(authManager);
                	}
                }

                checkout.run();
                LOG.debug("SVN checkout completed successfully.");
        	}
        		
            //if an optional directory parameter was given
            if(subDir!="")
            {
            	//copy appropriate path from checkout directory to target directory
            	FileSystemUtils.copyRecursively(new File(checkoutDirectory+subDir), new File(targetPath));
            }
            LOG.debug(String.format("cloned from %s via %s to %s", config.group(1), checkoutDirectory+subDir, targetDirectory));            
        }
        catch (IOException e) {
        	LOG.error(String.format("Error while cloning from %s: could not copy to unit test dir", config.group(1)), e);
        }
        catch (GitAPIException e) {
            LOG.error(String.format("Error while cloning from %s: could not read from Git", config.group(1)), e);
        }
        catch (SVNException e) {
        	LOG.error(String.format("Error while cloning from %s: could not read from Svn", config.group(1)), e);
        }
    }
}