using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using WinSCP;
using System.Data.Linq;
using System.Configuration;
using STP.Database.Report;
using System.Text.RegularExpressions;
using System.Threading;
using System.IO;

namespace COMMONUTIL.FTP
{
    public class FTPUtility
    {
        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        private string _connectionString;
        private Session _session;

        public FTPUtility(string connectionString, string FTPHost, string username)
        {
            _connectionString = connectionString;

            if (_session == null)
            {
                _session = new Session();
                _session.Open(GetSessionOptions(FTPHost, username));
            }
        }

        public void GetFile(string remoteFilePath, string localFilePath, string FTPHost, string username, bool delete_after)
        {
            try
            {
                Console.WriteLine("\n FTPUTIL: Get File: " + remoteFilePath);

                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;
                transferOptions.PreserveTimestamp = true;

                _session.GetFiles(remoteFilePath, localFilePath, delete_after, transferOptions).Check();

            }
            catch (Exception e)
            {
                log.Error("Exception retrieving file: " + remoteFilePath + ". \n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(GetFile()): " + e.Message);
            }
        }

        public List<string> ListFilesInDirectory(string remoteFilePath, string FTPHost, string username)
        {
            List<string> fileList = new List<string>();

            try
            {
                Console.WriteLine("\n FTPUTIL: Get File: " + remoteFilePath);

                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;
                transferOptions.PreserveTimestamp = true;

                RemoteDirectoryInfo directory = _session.ListDirectory(remoteFilePath);

                foreach (RemoteFileInfo file in directory.Files)
                    fileList.Add(file.Name);
                
            }
            catch (Exception e)
            {
                log.Error("Exception listing files in directory: " + remoteFilePath + ". \n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(ListFilesInDirectory()): " + e.Message);
            }

            return fileList;
        }

        public void PutFile(string remoteFilePath, string localFilepath, string FTPHost, string username, bool delete_after)
        {
            try
            {

                Console.WriteLine("\n FTPUTIL: Put File: " + remoteFilePath);

                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                _session.PutFiles(localFilepath, remoteFilePath, false, transferOptions).Check();
                
            }
            catch (Exception e)
            {
                log.Error("Exception putting file: " + remoteFilePath + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(PutFile()): " + e.Message);
            }
        }

        public void MoveFile(string sourceFilePath, string targetFilePath, string FTPHost, string username, bool delete_after)
        {
           
            try
            {
                Console.WriteLine("\n FTPUTIL: Move File: " + targetFilePath);

                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                _session.MoveFile(sourceFilePath, targetFilePath);

                if (delete_after)
                    _session.RemoveFiles(sourceFilePath);

            }
            catch (Exception e)
            {
                log.Error("Exception putting file: " + targetFilePath + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(MoveFile()): " + e.Message);
            }
            
        }

        public bool DirExists(string remoteDirectory, string FTPHost, string username)
        {
            bool ret = false;

            try
            {
                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                ret = _session.FileExists(remoteDirectory);
               
            }
            catch (Exception e)
            {
                log.Error("Exception checking if directory exists: " + remoteDirectory + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(DirExists()): " + e.Message);
            }

            return ret;
        }

        public void CreateDir(string remoteDirectory, string FTPHost, string username)
        {
            try
            {
                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                _session.CreateDirectory(remoteDirectory);
                
            }
            catch (Exception e)
            {
                log.Error("Exception creating directory: " + remoteDirectory + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(CreateDir()): " + e.Message);
            }

        }

        public bool FileExists(string remoteFilePath, string FTPHost, string username)
        {

            Console.WriteLine("\n FTPUTIL: File exists check: " + remoteFilePath);
            bool ret = false;

            try
            {
                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                ret = _session.FileExists(remoteFilePath);

                Console.WriteLine("\n FileExists SUCCESS");
            }
            catch (Exception e)
            {
                log.Error("Exception checking if file exists at location: " + remoteFilePath + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(FileExists()): " + e.Message);
            }

            return ret;
        }

        /// <summary>
        /// Poll for a file on an FTP server until its fully transferred on source 
        /// large files may take some time upload on server - this eliminates partial file pulls
        /// </summary>
        /// <param name="remoteFilePath">Remote FTP File Path</param>
        /// <param name="localFilePath">Local File Path to store file</param>
        /// <param name="FTPHost">FTP Host / IP address</param>
        /// <param name="username">FTP username</param>
        /// <param name="delete_after">delete file  on source after get</param>
        public void GetFullFile(string remoteFilePath, string localFilePath, string FTPHost, string username, bool delete_after)
        {
            try
            {
                Console.WriteLine("\n FTPUTIL: Get Full File: " + remoteFilePath);

                int previous_filesize = 0;
                int current_filesize = 1;
                int max_retry = 10;
                int current_try = 1;

                if (FileExists(remoteFilePath, FTPHost, username)) // only check if file already exists
                {
                    // Upload files
                    TransferOptions transferOptions = new TransferOptions();
                    transferOptions.TransferMode = TransferMode.Binary;
                    transferOptions.PreserveTimestamp = true;

                    while (current_try <= max_retry)  // Max 10 Trys
                    {
                        _session.GetFiles(remoteFilePath, localFilePath, delete_after, transferOptions).Check();
                        byte[] current_file = File.ReadAllBytes(localFilePath);
                        current_filesize = current_file.Length;

                        if (previous_filesize == current_filesize && current_filesize != 0)
                            break;

                        current_try++;
                        previous_filesize = current_filesize;
                        Thread.Sleep(1000); // Wait 3 seconds to try again.
                    }
                }
                
            }
            catch (Exception e)
            {
                log.Error("Exception retrieving full file: " + remoteFilePath + ". \n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(GetFile()): " + e.Message);
            }
        }

        //gets last modified file with naming convention provided
        public string GetFilename(string remoteFilePath, string FTPHost, string username, string file_name_pattern)
        {

            Console.WriteLine("\n FTPUTIL: Get Filename: " + remoteFilePath);
            string filename = "";

            try
            {
                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                RemoteDirectoryInfo directory_info = _session.ListDirectory(remoteFilePath);

                DateTime last_modified = new DateTime();
                foreach (RemoteFileInfo fileinfo in directory_info.Files)
                {
                    if (fileinfo.Name.Contains(file_name_pattern) && fileinfo.LastWriteTime > last_modified)
                    {
                        filename = fileinfo.Name;
                        last_modified = fileinfo.LastWriteTime;
                    }
                }
                
                Console.WriteLine("\n FileExists SUCCESS");
            }
            catch (Exception e)
            {
                log.Error("Exception checking if file exists at location: " + remoteFilePath + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(FileExists()): " + e.Message);
            }

            return filename;
        }


        //gets last modified file with naming convention provided
        public DateTime GetFileLastModifiedDateTime(string remoteFilePath, string FTPHost, string username, string file_name_pattern)
        {

            Console.WriteLine("\n FTPUTIL: GetFileLastModifiedDateTime: " + remoteFilePath);
            string filename = "";
            DateTime last_modified = new DateTime();

            try
            {
                // Upload files
                TransferOptions transferOptions = new TransferOptions();
                transferOptions.TransferMode = TransferMode.Binary;

                RemoteDirectoryInfo directory_info = _session.ListDirectory(remoteFilePath);

                foreach (RemoteFileInfo fileinfo in directory_info.Files)
                {
                    if (fileinfo.Name.Contains(file_name_pattern) && fileinfo.LastWriteTime > last_modified)
                    {
                        filename = fileinfo.Name;
                        last_modified = fileinfo.LastWriteTime;
                    }
                }
                
                Console.WriteLine("\n FileExists SUCCESS");
            }
            catch (Exception e)
            {
                log.Error("Exception checking if file exists at location: " + remoteFilePath + ".\n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                _session.Dispose();
                throw new Exception("FTPUtility EXCEPTION(FileExists()): " + e.Message);
            }

            return last_modified;
        }

        public SessionOptions GetSessionOptions(string FTPHost, string username)
        {
            SessionOptions sessionOptions = new SessionOptions();

            event_logDataContext db = new event_logDataContext(_connectionString);

            try
            {
                ISingleResult<proc_get_ftp_server_info_by_host_and_userResult> result = db.proc_get_ftp_server_info_by_host_and_user(FTPHost, "", username);
                foreach (proc_get_ftp_server_info_by_host_and_userResult r in result)
                {

                    string host = (r.ip != null && !r.ip.Trim().Equals("")) ? r.ip : r.url;

                    sessionOptions.Protocol = (r.secure.Equals('Y')) ? Protocol.Sftp : Protocol.Ftp;
                    sessionOptions.HostName = host;
                    sessionOptions.UserName = r.username;
                    sessionOptions.Password = r.pwd;

                    if (r.port != null && r.port > 0)
                        sessionOptions.PortNumber = r.port.Value;
                    else
                    {
                        if (sessionOptions.Protocol == Protocol.Ftp)
                            sessionOptions.PortNumber = 21;
                        else if (sessionOptions.Protocol == Protocol.Sftp)
                        {
                            sessionOptions.PortNumber = 22;
                            sessionOptions.SshHostKeyFingerprint = r.SshHostKeyFingerprint;
                        }
                    }
                    break;
                }
            }
            catch (Exception e)
            {
                log.Error("Exception getting session settings. \n FTP Host: " + FTPHost + "\n Username: " + username + " \n Exception: " + e.Message);
                throw new Exception("FTPUtility EXCEPTION(GetSessionOptions()): " + e.Message);
            }

            return sessionOptions;
        }

        public void CloseSession()
        {
            _session.Dispose();
        }
    }
}