using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using CsvHelper;
using CsvHelper.Configuration;
using HH.WCS.Mobox3.RiDong.generalMethod;
using HH.WCS.Mobox3.RiDong.models;

namespace HH.WCS.Mobox3.RiDong.util;

/// <summary>
/// 文件传输帮助类
/// </summary>
public static class FtpHelper
{
    /// <summary>
    /// 文件上传
    /// </summary>
    public static void Upload()
    {
        // 示例数据集合  
        var dataCollection = new List<DataItem>
        {
            new DataItem { Id = 1, Name = "Item1", Value = 10.5 },
            new DataItem { Id = 2, Name = "Item2", Value = 20.0 },
            new DataItem { Id = 3, Name = "Item3", Value = 30.75 }
        };

        string csvFilePath = Path.Combine(Path.GetTempPath(), "data.csv");
        string ftpUrl = "ftp://169.93.160.23/WMS/data.csv";
        string ftpUsername = "admin";
        string ftpPassword = "admin";

        // 生成CSV文件  
        GenerateCsv(dataCollection, csvFilePath);

        // 上传CSV文件到FTP  
        UploadFileToFtp(csvFilePath, ftpUrl, ftpUsername, ftpPassword);
    }

    /// <summary>
    /// 将数据生成为CSV文件
    /// </summary>
    /// <param name="dataCollection"></param>
    /// <param name="filePath"></param>
    static void GenerateCsv(List<DataItem> dataCollection, string filePath)
    {
        StringBuilder csvContent = new StringBuilder();
        csvContent.AppendLine("Id,Name,Value"); // CSV头部  
        foreach (var item in dataCollection)
        {
            csvContent.AppendLine($"{item.Id},{item.Name},{item.Value}");
        }

        File.WriteAllText(filePath, csvContent.ToString());
    }

    /// <summary>
    /// 文件上传方法
    /// </summary>
    /// <param name="filePath">文件路径</param>
    /// <param name="ftpUrl">ftp路径</param>
    /// <param name="username">ftp名称</param>
    /// <param name="password">ftp密码</param>
    static void UploadFileToFtp(string filePath, string ftpUrl, string username, string password)
    {
        using (WebClient client = new WebClient())
        {
            client.Credentials = new NetworkCredential(username, password);
            client.UploadFile(ftpUrl, WebRequestMethods.Ftp.UploadFile, filePath);
            Console.WriteLine("File uploaded successfully.");
        }
    }

    class DataItem
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public double Value { get; set; }
    }

    /// <summary>
    /// 下载文件
    /// </summary>
    public static void Download()
    {
        string ftpUrl = "ftp://192.168.89.1/AS400/";
        string ftpUsername = "TJY/ftp";

        // string ftpUrl = "ftp://169.93.160.23/AS400/";
        // string ftpUsername = "admin";
        // string ftpPassword = "admin";

        // string ftpUrl = "ftp://192.168.1.27/AS400/";
        // string ftpUsername = "WIN-7GJE5GQNO22/ftp";
        string ftpPassword = "1234";

        // 获取FTP目录下的所有文件
        FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftpUrl);
        request.Method = WebRequestMethods.Ftp.ListDirectory;
        request.Credentials = new NetworkCredential(ftpUsername, ftpPassword);

        try
        {
            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            using (Stream responseStream = response.GetResponseStream())
            using (StreamReader reader = new StreamReader(responseStream))
            {
                string fileName;
                while ((fileName = reader.ReadLine()) != null)
                {
                    string fileUrl = ftpUrl + fileName;
                    Console.WriteLine(fileUrl);
                    bool delete = false;

                    // 将fileName作为参数传递给ProcessFile方法
                    ProcessFile(fileUrl, fileName, ftpUsername, ftpPassword, ref delete);

                    // 删除查询到的一些数据
                    if (delete)
                    {
                        DeleteFile(fileUrl, ftpUsername, ftpPassword, fileName);
                    }
                }
            }
        }
        catch (WebException ex)
        {
            // 更详细地处理网络相关异常，比如根据不同的状态码采取不同措施
            if (((FtpWebResponse)ex.Response).StatusCode == FtpStatusCode.ActionNotTakenFileUnavailable)
            {
                Console.WriteLine($"文件不可用或已被删除，异常信息: {ex.Message}");
            }
            else
            {
                Console.WriteLine($"网络请求出现异常，异常信息: {ex.Message}");
                // 可以考虑记录详细日志等操作，方便后续排查问题
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"其他未知异常，异常信息: {ex.Message}");
            // 记录日志或者进行其他全局的异常处理操作
        }
    }

    /// <summary>
    /// 处理方法
    /// </summary>
    /// <param name="fileUrl"></param>
    /// <param name="fileName"></param>
    /// <param name="ftpUsername"></param>
    /// <param name="ftpPassword"></param>
    /// <param name="delete"></param>
    private static void ProcessFile(string fileUrl, string fileName, string ftpUsername, string ftpPassword, ref bool delete)
    {
        FtpWebRequest request1 = (FtpWebRequest)WebRequest.Create(fileUrl);
        request1.Method = WebRequestMethods.Ftp.DownloadFile;
        request1.Credentials = new NetworkCredential(ftpUsername, ftpPassword);

        var config = new CsvConfiguration(CultureInfo.InvariantCulture)
        {
            //Delimiter = ";",          // 自定义分隔符
            HasHeaderRecord = false,  // 无表头模式
            IgnoreBlankLines = true,   // 忽略空行
            AllowComments = true       // 允许注释行
        };

        try
        {
            using FtpWebResponse response1 = (FtpWebResponse)request1.GetResponse();
            using Stream responseStream1 = response1.GetResponseStream();
            if (responseStream1 == null) return;
            using (var csv = new CsvReader(new StreamReader(responseStream1, Encoding.UTF8), config))

                // using var csv = new CsvReader(new StreamReader(responseStream1, Encoding.UTF8), CultureInfo.InvariantCulture);

                if (fileName.StartsWith("MO"))
                {
                    List<MaterialOut> materialOuts = new List<MaterialOut>();

                    while (csv.Read())
                    {
                        MaterialOut materialOut = new MaterialOut
                        {
                            S_TRANSACTION = csv.GetField<string>(0),
                            S_TRAN_SUB_SEQ = csv.GetField<string>(1),
                            S_TRANSACTION_TYPE = csv.GetField<int>(2),
                            S_SO = csv.GetField<string>(3),
                            S_ORDER_LINE = csv.GetField<int>(4),
                            S_END_USER = csv.GetField<string>(5),
                            S_INT_ITEM_CODE = csv.GetField<string>(6),
                            S_INT_PRODUCT_CODE = csv.GetField<string>(7),
                            S_COLOR_CODE = csv.GetField<string>(8),
                            S_WAREHOUSE_CODE = csv.GetField<string>(9),
                            S_STORE = csv.GetField<string>(10),
                            S_LOT = csv.GetField<string>(11),
                            S_LOR_QUANTITYOT = csv.GetField<int>(12),
                            D_CREATION_DATE = csv.GetField<string>(13),
                            T_CREATION_TIME = csv.GetField<DateTime>(14),
                            S_USER_NAME = csv.GetField<string>(15),
                            S_ORIG_TRANSACTION = csv.GetField<string>(16),
                            D_RESULT_DATE = csv.GetField<string>(17),
                            T_RESULT_TIME = csv.GetField<DateTime>(18),
                            S_WMST = csv.GetField<string>(19),
                            S_ACTUAL_QUANTITY = csv.GetField<string>(20),
                            D_COMPLETE_DATE = csv.GetField<string>(21),
                            T_COMPLETE_TIME = csv.GetField<DateTime>(22)
                        };

                        if (AdoSqlMethod<MaterialOut>.QueryCount(p =>
                                p.S_TRANSACTION == materialOut.S_TRANSACTION) == 0)
                        {
                            var first = materialOuts.FirstOrDefault(p =>
                                p.S_TRANSACTION == materialOut.S_TRANSACTION &&
                                p.S_LOT == materialOut.S_LOT &&
                                p.S_INT_PRODUCT_CODE == materialOut.S_INT_PRODUCT_CODE);

                            if (first != null)
                            {
                                first.S_LOR_QUANTITYOT += materialOut.S_LOR_QUANTITYOT;
                            }
                            else
                            {
                                materialOuts.Add(materialOut);
                            }
                        }
                    }

                    // 将数据添加进数据库中，然后对于的数据需要生成任务
                    AdoSqlMethod<MaterialOut>.AddList(materialOuts);

                    // 写入领用单（要过滤的，用文件名当作单号，已经处理的不要重复处理，正常情况下处理完就删除了，测试时候关闭自动删除）
                    delete = true;
                }
                else if (fileName.StartsWith("DO"))
                {
                    List<DoOut> doOuts = new List<DoOut>();

                    while (csv.Read())
                    {
                        DoOut doOut = new DoOut
                        {
                            S_TRANSACTION = csv.GetField<string>(0),
                            S_TRAN_SUB_SEQ = csv.GetField<string>(1),
                            S_TRANSACTION_TYPE = csv.GetField<int>(2),
                            S_SO = csv.GetField<string>(3),
                            S_ORDER_LINE = csv.GetField<int>(4),
                            S_END_USER = csv.GetField<string>(5),
                            S_INT_ITEM_CODE = csv.GetField<string>(6),
                            S_INT_PRODUCT_CODE = csv.GetField<string>(7),
                            S_COLOR_CODE = csv.GetField<string>(8),
                            S_WAREHOUSE_CODE = csv.GetField<string>(9),
                            S_STORE = csv.GetField<string>(10),
                            S_LOT = csv.GetField<string>(11),
                            S_LOR_QUANTITYOT = csv.GetField<int>(12),
                            S_PRODUCT_SIGN = csv.GetField<string>(13),
                            D_CREATION_DATE = csv.GetField<string>(14),
                            T_CREATION_TIME = csv.GetField<DateTime>(15),
                            D_SEND_DATE = csv.GetField<string>(16),
                            T_SEND_TIME = csv.GetField<DateTime>(17),
                            S_USER_NAME = csv.GetField<string>(18),
                            S_ORIG_TRANSACTION = csv.GetField<string>(19),
                            D_RESULT_DATE = csv.GetField<string>(20),
                            T_RESULT_TIME = csv.GetField<DateTime>(21),
                            S_WMST = csv.GetField<string>(22),
                            S_ACTUAL_QUANTITY = csv.GetField<string>(23),
                            D_COMPLETE_DATE = csv.GetField<string>(24),
                            T_COMPLETE_TIME = csv.GetField<DateTime>(25),
                        };

                        if (AdoSqlMethod<DoOut>.QueryCount(p =>
                                p.S_TRANSACTION == doOut.S_TRANSACTION) == 0)
                        {
                            var first = doOuts.FirstOrDefault(p =>
                                p.S_TRANSACTION == doOut.S_TRANSACTION && p.S_LOT == doOut.S_LOT &&
                                p.S_INT_PRODUCT_CODE == doOut.S_INT_PRODUCT_CODE);

                            if (first != null)
                            {
                                first.S_LOR_QUANTITYOT += doOut.S_LOR_QUANTITYOT;
                            }
                            else
                            {
                                doOuts.Add(doOut);
                            }
                        }
                    }

                    // 将数据添加进数据库中，然后对于的数据需要生成任务
                    AdoSqlMethod<DoOut>.AddList(doOuts);
                    // 任务生成成功，打标记，然后将文件进行删除
                    // 写入出库单
                    delete = true;
                }
                else if (fileName.StartsWith("PRD"))
                {
                    List<TN_Material> tnMaterials = new List<TN_Material>();

                    while (csv.Read())
                    {
                        var type = csv.GetField<string>(19);
                        var type2 = "";

                        if (type == "C")
                        {
                            type2 = "制品";
                        }
                        else if (type == "R")
                        {
                            type2 = "原料";
                        }

                        var tnMaterial = new TN_Material()
                        {
                            // 规格编码
                            S_MATERIAL_CODE = csv.GetField<string>(0),
                            // 物料编码
                            S_ITEM_CODE = csv.GetField<string>(4),
                            // 规格
                            S_MATERIAL = csv.GetField<string>(5),
                            S_MATERIAL_TYPE = type2,
                            // F_WEIGHT = item.WEIGHT,
                        };

                        if (AdoSqlMethod<TN_Material>.QueryCount(p => p.S_ITEM_CODE == tnMaterial.S_ITEM_CODE) == 0)
                        {
                            // AdoSqlMethod<Item>.QueryFirst(p=>p.INTERNAL_ITEM_CODE == tnMaterial.INTERNAL_ITEM_CODE);
                            tnMaterials.Add(tnMaterial);
                        }
                    }

                    // 将数据添加进数据库中
                    AdoSqlMethod<TN_Material>.AddList(tnMaterials);

                    // 任务生成成功，打标记，然后将文件进行删除
                    // 写入出库单
                    delete = true;
                }
                else if (fileName.StartsWith("ITM"))
                {
                    int readNumber = 0;
                    int updateNumber = 0;

                    while (csv.Read())
                    {
                        readNumber++;

                        var INTERNAL_ITEM_CODE = csv.GetField<string>(2);

                        var tnMaterial = AdoSqlMethod<TN_Material>.QueryFirst(p =>
                            p.S_ITEM_CODE == INTERNAL_ITEM_CODE);

                        if (tnMaterial != null)
                        {
                            tnMaterial.S_ITEM_NAME = csv.GetField<string>(0);

                            AdoSqlMethod<TN_Material>.UpdateFirst(tnMaterial, p => new { p.S_ITEM_NAME });
                            updateNumber++;
                        }
                    }

                    if (readNumber == updateNumber)
                    {
                        // 读取的数据条数和操作的数据条数一致删除
                        delete = true;
                    }
                }
        }
        catch (CsvHelperException csvEx)
        {
            Console.WriteLine($"CSV文件解析出现异常，异常信息: {csvEx.Message}");
            // 对于CSV解析异常，可以考虑记录日志、跳过该文件等操作，避免影响后续文件处理
        }
        catch (Exception ex)
        {
            Console.WriteLine($"文件处理过程中出现其他未知异常，异常信息: {ex.Message}");
            // 进行通用的异常处理，比如记录日志等
        }
    }

    /// <summary>
    /// 删除文件
    /// </summary>
    /// <param name="fileUrl"></param>
    /// <param name="ftpUsername"></param>
    /// <param name="ftpPassword"></param>
    /// <param name="fileName"></param>
    private static void DeleteFile(string fileUrl, string ftpUsername, string ftpPassword, string fileName)
    {
        FtpWebRequest deleteRequest = (FtpWebRequest)WebRequest.Create(fileUrl);
        deleteRequest.Method = WebRequestMethods.Ftp.DeleteFile;
        deleteRequest.Credentials = new NetworkCredential(ftpUsername, ftpPassword);

        try
        {
            using (FtpWebResponse deleteResponse = (FtpWebResponse)deleteRequest.GetResponse())
            {
                Console.WriteLine($"Deleted {fileName}: {deleteResponse.StatusDescription}");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine($"删除文件时出现网络异常，异常信息: {ex.Message}");
            // 根据具体情况决定是否需要重试删除操作或者记录详细信息等
        }
        catch (Exception ex)
        {
            Console.WriteLine($"删除文件时出现其他未知异常，异常信息: {ex.Message}");
            // 进行合适的异常处理，比如记录日志等
        }
    }

    class Test1
    {
        public string location { get; set; }
        public string actionType { get; set; }
        public string code { get; set; }
        //Parse方法会在自定义读写CSV文件时用到
        public static Test1 Parse(string[] fields)
        {
            try
            {
                Test1 ret = new Test1();
                ret.location = fields[0];
                ret.actionType = fields[1];
                ret.code = fields[2];

                return ret;
            }
            catch (Exception ex)
            {
                //做一些异常处理，写日志之类的
                return null;
            }
        }
    }

    /// <summary>
    /// 文件复制
    /// </summary>
    private static void FileCopy()
    {

    }
}