using Newtonsoft.Json;
using System;
using System.Configuration;
using System.IO;
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 = "------------------------";

        #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);

                        // 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;

                                default:
                                    break;
                            }


                            Console.WriteLine(esitoStep);
                            Console.WriteLine($"------ Done Step {item.id} ------");
                            Console.WriteLine();
                            Console.WriteLine("Press a key to continue...");
                            Console.ReadKey();
                        }
                    }
                }
            }
            // 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
    }
}