using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Collections.Concurrent;

using Saraff.Twain;
using HXX.Scanner.Common;
using HXX.Scanner.Biz.Socket;
using HXX.Scanner.Database;

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace HXX.Scanner.Biz
{
    /// <summary>
    /// 扫描生成的图片文件相关
    /// </summary>
    public class file_manager
    {
        /// <summary>
        /// 当前扫描参数，复制自startScan，仅正式扫描生效
        /// </summary>
        private static file_batch_info current_scanner_parameter { get; set; }
        /// <summary>
        /// 本次扫描生成的所有文件集合
        /// </summary>
        public static ConcurrentDictionary<string, file_info> dic_file_list { get; set; }
        /// <summary>
        /// 弹框扫描是否已经初始化标记
        /// </summary>
        private static bool init_use_source_ui { get; set; }
        /// <summary>
        /// 同步块
        /// </summary>
        private static object lockObj = new object();
        /// <summary>
        /// 上传结果通知2
        /// </summary>
        public static del_http_notify2 on_http_notify2;
        /// <summary>
        /// 初始化，由startScan调用
        /// </summary>
        /// <param name="data"></param>
        public static void Init(cmd_startScan2 data)
        {
            current_scanner_parameter = EntityClone.DeriveCopy<cmd_startScan2, file_batch_info>(data);
            dic_file_list = new ConcurrentDictionary<string, file_info>();
            init_use_source_ui = false;
        }

        /// <summary>
        /// 获取当前扫描的图片，应该设置的文件参数信息
        /// </summary>
        /// <param name="engine"></param>
        /// <returns></returns>
        public static file_info get_file_info(Twain32 engine)
        {
            lock (lockObj)
            {
                init_when_use_source_ui(engine);

                return get_file_info2();
            }
        }

        /// <summary>
        /// 获取当前扫描的图片，应该设置的文件参数信息，主要是即将保存的文件名
        /// </summary>
        /// <returns></returns>
        public static file_info get_file_info2()
        {
            file_info info = EntityClone.DeriveCopy<file_batch_info, file_info>(current_scanner_parameter);

            //倘若是背面
            if (info.current_side == 2)
            {
                //获取数据库保存的正面的信息
                var brother = dic_file_list.FirstOrDefault(x => x.Value.SN == dic_file_list.Max(y => y.Value.SN) && x.Value.current_side == 1);

                if (brother.Value != null)
                {
                    //同一张纸的正反面拥有同一个sn
                    info.SN = brother.Value.SN;
                }
                else
                {
                    info.SN = CommonOperation.GetTimeStamp();
                }
            }
            else
            {
                info.SN = CommonOperation.GetTimeStamp();
            }

            info.file_path = get_path();
            //info.file_ext = engine.Capabilities.ImageFileFormat.GetCurrent().ToString().ToLower();
            //info.file_ext = "jpeg";
            info.zipId = current_scanner_parameter.current_page++;
            info.file_ext = "bmp";
            //info.file_name = info.SN + "-" + info.zipId + "-" + info.current_side + "." + info.file_ext;
            info.file_name = info.zipId.ToString().PadLeft(6, '0') + "." + info.file_ext;
            info.file_full_name = info.file_path + info.file_name;            

            dic_file_list[info.file_full_name] = info;

            change_side();

            return info;
        }

        /// <summary>
        /// 弹框扫描时的初始化
        /// </summary>
        /// <param name="engine"></param>
        private static void init_when_use_source_ui(Twain32 engine)
        {
            if (current_scanner_parameter.isLocalConfig == "1" && !init_use_source_ui)
            {
                var c_paper = engine.Capabilities.SupportedSizes.Get();
                var c_ab = engine.Capabilities.DuplexEnabled.Get();

                var paper = c_paper[c_paper.CurrentIndex].ToString();
                var ab = c_ab[c_ab.CurrentIndex].ToString().ToLower();

                var r_paper = biz_environment.get_paper_size(paper);

                current_scanner_parameter.paperSize = r_paper.Item1;
                config_environment.web_parameter.paperSize = r_paper.Item1;
                config_environment.paper_size = r_paper.Item2;

                var scanner = scanner_manager.get_current();
                scanner.setPaperSize(config_environment.paper_size);

                if (ab == "true")
                {
                    current_scanner_parameter.paperSchema = 2;
                    config_environment.web_parameter.paperSchema = 2;
                    config_environment.scan_ab = true;
                }
                else
                {
                    current_scanner_parameter.paperSchema = 1;
                    config_environment.web_parameter.paperSchema = 1;
                    config_environment.scan_ab = false;
                }

                init_use_source_ui = true;
            }
        }

        ///// <summary>
        ///// 获取文件保存路径
        ///// </summary>
        ///// <returns></returns>
        //private static string get_path()
        //{
        //    StringBuilder sb = new StringBuilder();
        //    var xx = config_manager.Get("dataDir");

        //    if (config_environment.scan_state)
        //    {
        //        if (current_scanner_parameter != null)
        //        {
        //            if (!string.IsNullOrEmpty(config_manager.Get("dataDir")))
        //            {
        //                sb.Append(config_manager.Get("dataDir") + @"\");
        //                //sb.Append(DateTime.Now.Year.ToString() + "." + DateTime.Now.Month.ToString().PadLeft(2, '0') + @"\");
        //                //sb.Append(DateTime.Now.Year.ToString() + @"\");
        //                sb.Append(DateTime.Now.ToString("yyyyMMdd") + @"\");
        //                //sb.Append(current_scanner_parameter.schoolId + @"\");
        //                sb.Append(current_scanner_parameter.examId + "-" + current_scanner_parameter.examPaperId + @"\");
        //                //sb.Append(current_scanner_parameter.examPaperId + @"\");
        //                sb.Append(current_scanner_parameter.batchNumber + @"\");

        //                //if (!string.IsNullOrEmpty(current_scanner_parameter.batchNumber))
        //                //{
        //                //    sb.Append(current_scanner_parameter.batchNumber + @"\");
        //                //}
        //                //else
        //                //{
        //                //    sb.Append(@"0\");
        //                //}
        //            }
        //        }
        //    }

        //    var dir = sb.ToString();

        //    if (!string.IsNullOrEmpty(dir))
        //    {
        //        if (!Directory.Exists(dir))
        //        {
        //            Directory.CreateDirectory(dir);
        //        }
        //    }

        //    return dir;
        //}

        /// <summary>
        /// 获取文件保存路径
        /// </summary>
        /// <returns></returns>
        private static string get_path()
        {
            StringBuilder sb = new StringBuilder();
            //var xx = config_manager.Get("dataDir");

            //if (config_environment.scan_state)
            {
                if (current_scanner_parameter != null)
                {
                    if (!string.IsNullOrEmpty(config_manager.Get("dataDir")))
                    {
                        sb.Append(config_manager.Get("dataDir") + @"\");
                        sb.Append(DateTime.Now.ToString("yyyyMMdd") + @"\");
                        sb.Append(current_scanner_parameter.subjectCode + @"\");
                        sb.Append(current_scanner_parameter.batchNumber + @"\");
                    }
                }
            }

            var dir = sb.ToString();
            var dir_ready = dir + @"ready\";
            var dir_complete = dir + @"complete\";

            if (!string.IsNullOrEmpty(dir))
            {
                if (!Directory.Exists(dir))
                {
                    Directory.CreateDirectory(dir);
                }

                if (!Directory.Exists(dir_ready))
                {
                    Directory.CreateDirectory(dir_ready);
                }

                if (!Directory.Exists(dir_complete))
                {
                    Directory.CreateDirectory(dir_complete);
                }
            }

            return dir_ready;
        }

        /// <summary>
        /// 翻面操作，用于双面扫描时计算文件名
        /// </summary>
        private static void change_side()
        {
            if (current_scanner_parameter.paperSchema == 2)
            {
                if (current_scanner_parameter.current_side == 1)
                {
                    current_scanner_parameter.current_side = 2;
                }
                else
                {
                    current_scanner_parameter.current_side = 1;

                    //current_scanner_parameter.current_page++;
                }
            }
            else
            {
                //current_scanner_parameter.current_page++;
            }
        }

        /// <summary>
        /// 保存文件（包括转换图片格式，保存数据库和上传http）
        /// </summary>
        /// <param name="fileName"></param>
        public static void save(string fileName)
        {
            Task.Run(() =>
            {
                try
                {
                    save_detail(fileName);
                }
                catch (Exception ee)
                {
                    LogManager.WriteLog(ee);
                }
            });
        }

        /// <summary>
        /// 临时变量
        /// </summary>
        public static int temp_count = 0;

        ///// <summary>
        ///// 保存文件 详细
        ///// </summary>
        ///// <param name="fileName"></param>
        //private static void save_detail(string fileName)
        //{
        //    ResponseEntity<response_http_uploadImg> _result = new ResponseEntity<response_http_uploadImg>() { Status = -1 };
        //    tb_file_info entity = null;

        //    //在保存文件前，就抢先把文件信息放入http上传队列
        //    var e_q = new upf() { entity = null, result = _result, seqNumber = 0 };

        //    if (config_environment.scan_type != ScanType.Test_Panel_1_Side && config_environment.scan_type != ScanType.Test_Panel_2_Sides)
        //    {
        //        new http_manager().Upload(e_q);
        //    }

        //    try
        //    {
        //        string dstFileName = fileName;

        //        //文件格式转换，bmp转jpg
        //        if (fileName.EndsWith(".tiff"))
        //        {
        //            dstFileName = fileName.Substring(0, fileName.Length - 1);
        //            //压缩图片
        //            Device_Scanner.zipImage(fileName, dstFileName, true);
        //        }
        //        else if (fileName.EndsWith(".bmp"))
        //        {
        //            //dstFileName = fileName.Substring(0, fileName.Length - 3) + "tif";
        //            dstFileName = fileName.Substring(0, fileName.Length - 3) + "jpeg";
        //            //压缩图片
        //            Device_Scanner.zipImage_jpeg(fileName, dstFileName, true);
        //        }
        //        else if (fileName.EndsWith(".jpeg"))
        //        {
        //            fileName = fileName.Replace(".jpeg", ".bmp");
        //        }

        //        temp_count++;

        //        //测试扫描 单面
        //        if (config_environment.scan_type == ScanType.Test_Panel_1_Side)
        //        {
        //            _result.Status = 11;
        //            _result.Message = "test scan 1";
        //            System.Diagnostics.Process.Start("explorer.exe", config_manager.Get("dataDir"));
        //            return;
        //        }
        //        //测试扫描 双面
        //        else if (config_environment.scan_type == ScanType.Test_Panel_2_Sides)
        //        {
        //            if (temp_count % 2 == 1)
        //            {
        //                _result.Status = 11;
        //                _result.Message = "test scan 2";
        //                System.Diagnostics.Process.Start("explorer.exe", config_manager.Get("dataDir"));
        //                return;
        //            }
        //        }
        //        //正式扫描
        //        else
        //        {
        //            var file = dic_file_list.FirstOrDefault(x => x.Key == fileName).Value;

        //            if (file != null)
        //            {
        //                //更新文件信息
        //                change_file(file, dstFileName);
        //                //保存数据库
        //                e_q.entity = new biz_db().Add(file);

        //                _result.Status = 1;
        //                _result.Message = "ok";
        //            }
        //            else
        //            {
        //                _result.Status = 0;
        //                _result.Message = "file not found 5";
        //            }
        //        }
        //    }
        //    catch (Exception ee)
        //    {
        //        entity = null;
        //        _result.Status = 0;
        //        _result.Message = ee.Message;

        //        LogManager.WriteLog(ee);
        //    }

        //    //new http_manager().Upload(entity, result);
        //}

        /// <summary>
        /// 保存文件 详细
        /// </summary>
        /// <param name="fileName"></param>
        private static void save_detail(string fileName)
        {
            ResponseEntity<response_http_uploadImg2> _result = new ResponseEntity<response_http_uploadImg2>() { Status = -1 };

            //在保存文件前，就抢先把文件信息放入http上传队列
            var e_q = new upf() { entity = null, result = _result, upload_type = upload_type_enum.normal };

            try
            {
                string dstFileName = fileName;

                //文件格式转换，bmp转jpg
                if (fileName.EndsWith(".tiff"))
                {
                    dstFileName = fileName.Substring(0, fileName.Length - 1);
                    //压缩图片
                    Device_Scanner.zipImage(fileName, dstFileName, true);
                }
                else if (fileName.EndsWith(".bmp"))
                {
                    //dstFileName = fileName.Substring(0, fileName.Length - 3) + "tif";
                    dstFileName = fileName.Substring(0, fileName.Length - 3) + "jpeg";
                    //压缩图片
                    Device_Scanner.zipImage_jpeg(fileName, dstFileName, true);
                }
                else if (fileName.EndsWith(".jpeg"))
                {
                    fileName = fileName.Replace(".jpeg", ".bmp");
                }

                temp_count++;

                //测试扫描 单面
                if (config_environment.scan_type == ScanType.Test_Panel_1_Side)
                {
                    _result.Status = 11;
                    _result.Message = "test scan 1";
                    System.Diagnostics.Process.Start("explorer.exe", config_manager.Get("dataDir"));
                    return;
                }
                //测试扫描 双面
                else if (config_environment.scan_type == ScanType.Test_Panel_2_Sides)
                {
                    if (temp_count % 2 == 1)
                    {
                        _result.Status = 11;
                        _result.Message = "test scan 2";
                        System.Diagnostics.Process.Start("explorer.exe", config_manager.Get("dataDir"));
                        return;
                    }
                }
                //正式扫描
                else
                {
                    if (config_environment.scan_type2 == ScanType.Formal)
                    {
                        var file = dic_file_list.FirstOrDefault(x => x.Key == fileName).Value;

                        if (file != null)
                        {
                            //更新文件信息
                            change_file(file, dstFileName);
                            //保存数据库
                            e_q.entity = new biz_db().Add(file);

                            _result.Status = 1;
                            _result.Message = "ok";

                            new http_manager().Upload(e_q);
                        }
                        else
                        {
                            _result.Status = 0;
                            _result.Message = "file not found 5";
                        }

                        if (e_q.entity.fi_side == 1)
                        {
                            //socket发送结果
                            var count = new biz_db().get_count_by_batchNumber(e_q.entity.fi_batchSeq, e_q.entity.fi_subjectCode);
                            var response = new response_scanNumber() { number = count, batchNumber = e_q.entity.fi_batchSeq, subjectCode = e_q.entity.fi_subjectCode };
                            on_http_notify2(JsonConvert.SerializeObject(response));
                        }
                    }
                    else if (config_environment.scan_type2 == ScanType.ScanTemplate)
                    {
                        var response = new response_scanTemplate();

                        response.batchNumber = config_environment.web_parameter.batchNumber;
                        response.subjectCode = config_environment.web_parameter.subjectCode;
                        response.url = self_http_manager.get_url(dstFileName);
                        response.name = Path.GetFileName(dstFileName);
                        response.full_name = dstFileName;

                        on_http_notify2(JsonConvert.SerializeObject(response));
                    }
                }
            }
            catch (Exception ee)
            {
                _result.Status = 0;
                _result.Message = ee.Message;

                LogManager.WriteLog(ee);
            }

            //new http_manager().Upload(entity, result);
        }

        /// <summary>
        /// 更新文件信息
        /// </summary>
        /// <param name="file"></param>
        /// <param name="dstFileName"></param>
        private static void change_file(file_info file, string dstFileName)
        {
            file.file_full_name = dstFileName;
            file.file_name = Path.GetFileName(dstFileName);
            file.file_ext = Path.GetExtension(file.file_name).Replace(".", "");
        }

        /// <summary>
        /// 判断http上传的seqNumber
        /// </summary>
        /// <returns></returns>
        public static int get_seqNumber()
        {
            int result = 1;

            if (current_scanner_parameter != null)
            {
                result = current_scanner_parameter.current_page++;
            }

            return result;
        }
    }
}