using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using static System.Net.Mime.MediaTypeNames;

namespace EgwProxy.Ftp.Test
{
    internal class Program
    {
        #region Protected Methods

        /// <summary>
        /// legge conf in formato stringa
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        protected static string ReadSetting(string key)
        {
            string answ = "";
            try
            {
                answ = $"{ConfigurationManager.AppSettings[key]}" ?? "";
            }
            catch (Exception exc)
            {
                Console.Write("Eccezione in ReadSettings");
                Console.Write(exc.Message);
            }
            return answ;
        }

        #endregion Protected Methods

        #region Private Fields

        /// <summary>
        /// Helper separatore dash
        /// </summary>
        private const string separator = "------------------------";

        private static Stopwatch sw = new Stopwatch();

        #endregion Private Fields

        #region Private Methods

        /// <summary>
        /// Programma principale
        /// </summary>
        /// <param name="args"></param>
        private static void Main(string[] args)
        {
            Console.WriteLine(separator);
            Console.WriteLine("Test FTP Client");
            Console.WriteLine(separator);
            Console.WriteLine();
            string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
            string BaseDirectory = System.IO.Path.GetDirectoryName(exePath);
            string testFile = Path.Combine(BaseDirectory, ReadSetting("testFile"));
            Manager ftpClient = new Manager("", "", "", "", false);
            if (!string.IsNullOrEmpty(testFile))
            {
                Console.WriteLine(separator);
                Console.WriteLine($"Mode json ({testFile})");
                Console.WriteLine(separator);
                Console.WriteLine();
                if (File.Exists(testFile))
                {
                    var rawData = File.ReadAllText(testFile);
                    if (!string.IsNullOrEmpty(rawData))
                    {
                        TestSetup testConf = new TestSetup();
                        try
                        {
                            testConf = JsonConvert.DeserializeObject<TestSetup>(rawData);
                        }
                        catch
                        { }
                        // setup server
                        ftpClient = new Manager(testConf.server, testConf.user, testConf.password, testConf.rawCert, testConf.skipCert);
                        serverTest(ftpClient);

                        bool doRepeat = true;
                        while (doRepeat)
                        {
                            // eseguo per ogni step
                            foreach (var item in testConf.steps)
                            {
                                Console.WriteLine($"------ Step {item.id} | {item.description} ------");
                                string esitoStep = "";
                                switch (item.action)
                                {
                                    case stepType.checkDir:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string dir2check = item.paramList[0];
                                            var dirCheckExists = ftpClient.DirExists(dir2check);
                                            esitoStep = dirCheckExists ? $"Directory {dir2check} found!" : $"Directory {dir2check} NOT found!";
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.checkFile:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string file2check = item.paramList[0];
                                            var dirCheckExists = ftpClient.FileExists(file2check);
                                            esitoStep = dirCheckExists ? $"File {file2check} found!" : $"File {file2check} NOT found!";
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.createDir:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string dir2check = item.paramList[0];
                                            var preTest = ftpClient.DirExists(dir2check);
                                            if (preTest)
                                            {
                                                esitoStep = "Error: Folder already exists!";
                                            }
                                            else
                                            {
                                                var dirCreate = ftpClient.CreateDir(dir2check);
                                                esitoStep = dirCreate ? $"Directory {dir2check} created!" : $"Error: {dir2check} NOT created!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.delDir:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string dir2check = item.paramList[0];
                                            var preTest = ftpClient.DirExists(dir2check);
                                            if (preTest)
                                            {
                                                var dirDelete = ftpClient.DeleteDir(dir2check);
                                                esitoStep = dirDelete ? $"Directory {dir2check} deleted!" : $"Error: {dir2check} NOT deleted!";
                                            }
                                            else
                                            {
                                                esitoStep = "Error: Folder doesn't exists, delete not possible!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.delFile:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string file2check = item.paramList[0];
                                            var preTest = ftpClient.FileExists(file2check);
                                            if (preTest)
                                            {
                                                var dirDelete = ftpClient.DeleteFile(file2check);
                                                esitoStep = dirDelete ? $"File {file2check} deleted!" : $"Error: {file2check} NOT deleted!";
                                            }
                                            else
                                            {
                                                esitoStep = "Error: File doesn't exists, delete not possible!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.downloadDir:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            string dir2check = item.paramList[0];
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
                                            var preTest = ftpClient.DirExists(dir2check);
                                            if (preTest)
                                            {
                                                var dirDelete = ftpClient.GetDir(localDir, dir2check);
                                                esitoStep = dirDelete ? $"Directory {dir2check} downloaded!" : $"Error: {dir2check} NOT downloaded!";
                                            }
                                            else
                                            {
                                                esitoStep = "Error: Folder doesn't exists, download not possible!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        break;

                                    case stepType.downloadFile:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            string dir2check = item.paramList[0];
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
                                            var preTest = ftpClient.DirExists(dir2check);
                                            if (preTest)
                                            {
                                                var dirDelete = ftpClient.GetDir(localDir, dir2check);
                                                esitoStep = dirDelete ? $"Directory {dir2check} downloaded!" : $"Error: {dir2check} NOT downloaded!";
                                            }
                                            else
                                            {
                                                esitoStep = "Error: Folder doesn't exists, download not possible!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        break;

                                    case stepType.uploadDir:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            string remoteDir = item.paramList[0];
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
                                            var dirUploaded = ftpClient.SendDir(localDir, remoteDir);
                                            esitoStep = dirUploaded ? $"Directory {remoteDir} uploaded!" : $"Error: {remoteDir} NOT uploaded!";
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        break;

                                    case stepType.uploadFile:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            string remotePath = item.paramList[0];
                                            string localPath = Path.Combine(BaseDirectory, item.paramList[1]);
                                            var fileUploaded = ftpClient.SendFile(localPath, remotePath);
                                            esitoStep = fileUploaded ? $"File {remotePath} uploaded!" : $"Error: {remotePath} NOT uploaded!";
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        break;

                                    case stepType.listContent:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            string remoteDir = item.paramList[0];
                                            var preTest = ftpClient.DirExists(remoteDir);
                                            if (preTest)
                                            {
                                                var listResult = ftpClient.ListDir(remoteDir, false);
                                                Console.WriteLine($"Content of dir {remoteDir}:");
                                                foreach (var itemList in listResult)
                                                {
                                                    Console.WriteLine(itemList);
                                                }
                                            }
                                            else
                                            {
                                                esitoStep = "Error: Folder doesn't exists, list not possible!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameter!";
                                        }
                                        break;

                                    case stepType.genRandomDir:
                                        if (item.paramList != null && item.paramList.Count > 0)
                                        {
                                            sw.Restart();
                                            // crea una struttura ricorsiva di 3 livelli con 20 file
                                            // con contenuto random ogni livello
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[0]);
                                            if (!Directory.Exists(localDir))
                                            {
                                                Directory.CreateDirectory(localDir);
                                            }
                                            // ora vado a creare 3 livelli di folder
                                            int numDepth = 3;
                                            int numFile = 20;
                                            int numRows = 1000;
                                            string baseDir = localDir;
                                            for (int iDir = 0; iDir < numDepth; iDir++)
                                            {
                                                DateTime adesso = DateTime.Now;
                                                string newSub = $"{adesso:HHmmss_fff}";
                                                // sposto puntamento folder...
                                                baseDir = Path.Combine(baseDir, newSub);
                                                if (!Directory.Exists(baseDir))
                                                {
                                                    Directory.CreateDirectory(baseDir);
                                                }
                                                for (int iFile = 0; iFile < numFile; iFile++)
                                                {
                                                    string filePath = Path.Combine(baseDir, $"File_{iFile:000}.txt");
                                                    using (StreamWriter writer = new StreamWriter(filePath))
                                                    {
                                                        StringBuilder sb = new StringBuilder();
                                                        // compongo un testo di numRow righe da GUID...
                                                        for (int i = 0; i < numRows; i++)
                                                        {
                                                            var newId = Guid.NewGuid();
                                                            sb.AppendLine($"{DateTime.Now:HH:mm:ss.ffffff} | {newId} | {newId}");
                                                        }
                                                        writer.WriteLine(sb.ToString());
                                                    }
                                                }
                                            }
                                            sw.Stop();
                                            esitoStep = $"Completata generazione test data: {sw.ElapsedMilliseconds:N1} ms";
                                        }
                                        break;

                                    case stepType.mirrorDirL2R:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            sw.Restart();
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[0]);
                                            string remoteDir = item.paramList[1];
                                            var preTest = ftpClient.DirExists(remoteDir);
                                            if (!preTest)
                                            {
                                                ftpClient.CreateDir(remoteDir);
                                            }

                                            var mirrorDone = ftpClient.SendDir(localDir, remoteDir, FluentFTP.FtpFolderSyncMode.Mirror);
                                            esitoStep = mirrorDone ? $"Directory {localDir} mirrored L2R!" : $"Error: {remoteDir} NOT mirrored!";
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        sw.Stop();
                                        esitoStep = $"Completato mirror L2R: {sw.ElapsedMilliseconds:N1} ms";
                                        break;

                                    case stepType.mirrorDirR2L:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            sw.Restart();
                                            string remoteDir = item.paramList[0];
                                            string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
                                            var preTest = ftpClient.DirExists(remoteDir);
                                            if (preTest)
                                            {
                                                var mirrorDone = ftpClient.GetDir(localDir, remoteDir, FluentFTP.FtpFolderSyncMode.Mirror);
                                                esitoStep = mirrorDone ? $"Directory {remoteDir} mirrored R2L!" : $"Error: {remoteDir} NOT mirrored!";
                                            }
                                            else
                                            {
                                                esitoStep = "Dir remota non trovata!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        sw.Stop();
                                        esitoStep = $"Completato mirror R2L: {sw.ElapsedMilliseconds:N1} ms";
                                        break;

                                    case stepType.delFileList:
                                        if (item.paramList != null && item.paramList.Count > 1)
                                        {
                                            sw.Restart();
                                            string remoteDir = item.paramList[0];
                                            string fileSearch= item.paramList[1];
                                            List<FluentFTP.FtpListItem> resList = ftpClient.GetRemoteList(remoteDir, true);
                                            // cerco solo i file di tipo fileSearch
                                            List<FluentFTP.FtpListItem> resListFilt = new List<FluentFTP.FtpListItem>();
                                            foreach (var flItem in resList)
                                            {
                                                if(flItem.Type == FluentFTP.FtpObjectType.File && flItem.Name.EndsWith(fileSearch))
                                                {
                                                    resListFilt.Add(flItem);
                                                }
                                            }
                                            // elimino quelli trovati
                                            if (resListFilt.Count>0)
                                            {
                                                var fList = resListFilt.Select(x => x.FullName).ToList();
                                                var numDel = ftpClient.DeleteFileList(fList);
                                                // indico esito eliminazione
                                                esitoStep = $"Eliminati {numDel}/{resListFilt.Count} file";
                                            }
                                            else
                                            {
                                                esitoStep = "File non trovati!";
                                            }
                                        }
                                        else
                                        {
                                            esitoStep = "Error: missing parameters!";
                                        }
                                        sw.Stop();
                                        esitoStep += $"{Environment.NewLine}Completato GetRemotList : {sw.ElapsedMilliseconds:N1} ms";
                                        break;

                                    default:
                                        break;
                                }

                                Console.WriteLine(esitoStep);
                                Console.WriteLine($"------ Done Step {item.id} ------");
                                Console.WriteLine();
                                Console.WriteLine("Press a key to continue...");
                                Console.ReadKey();
                            }
                            Console.WriteLine();
                            Console.WriteLine("Do you want to repeat from the beginnning? esc to close");
                            ConsoleKeyInfo answ = Console.ReadKey();
                            doRepeat = answ.Key != ConsoleKey.Escape;
                        }
                    }
                }
            }
            // test base su server steamware
            else
            {
                Console.WriteLine(separator);
                Console.WriteLine("Mode: base");
                Console.WriteLine(separator);
                Console.WriteLine();

                string sSkipCert = ReadSetting("skipCert");
                bool skipCert = false;
                bool.TryParse(sSkipCert, out skipCert);
                ftpClient = new Manager(ReadSetting("server"), ReadSetting("userName"), ReadSetting("passwd"), ReadSetting("rawCert"), skipCert);
                serverTest(ftpClient);

                Console.WriteLine("--- Folder ---");
                var testExists = ftpClient.DirExists($"data/test_folder");
                if (testExists)
                {
                    Console.WriteLine("Folder already exists!");
                }
                else
                {
                    Console.WriteLine("--- Create folder ---");
                    var testCreate = ftpClient.CreateDir($"data/test_folder");
                    Console.WriteLine();
                }

                Console.WriteLine("Contenuto folder remota: ");
                var folderContent = ftpClient.ListDir("data/", true);
                foreach (var item in folderContent)
                {
                    Console.WriteLine(item);
                }
                Console.WriteLine();
                Console.WriteLine("Premere un tasto x continuare...");
                Console.ReadKey();

                Console.WriteLine("--- Upload file ---");
                ftpClient.SendFile("test/FileProva.txt", "data/test_folder/FileProva.txt");
                Console.WriteLine("Contenuto folder remota: ");
                folderContent = ftpClient.ListDir("data/", true);
                foreach (var item in folderContent)
                {
                    Console.WriteLine(item);
                }

                Console.WriteLine();
                Console.WriteLine("Premere un tasto x continuare...");
                Console.ReadKey();

                Console.WriteLine("--- Download File ---");

                ftpClient.GetFile("test/FileProva_02.txt", "data/test_folder/FileProva.txt");
                Console.WriteLine("Contenuto folder remota: ");
                folderContent = ftpClient.ListDir("data/", true);
                foreach (var item in folderContent)
                {
                    Console.WriteLine(item);
                }

                Console.WriteLine();
                Console.WriteLine("Premere un tasto x continuare...");
                Console.ReadKey();
            }
        }

        private static void serverTest(Manager ftpClient)
        {
            Console.WriteLine(separator);
            var testServer = ftpClient.ServerOk();
            Console.WriteLine($"Test connessione: esito {testServer}");
            var srvType = ftpClient.ServerType();
            Console.WriteLine($"Server: {srvType}");
            Console.WriteLine(separator);
            Console.WriteLine();
        }

        #endregion Private Methods
    }
}