using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Configuration;
using System.Windows.Forms;
using System.Threading;
using System.Diagnostics;

using Saraff.Twain;
using HXX.Scanner.Common;
using HXX.Scanner.Biz.Socket;
using HXX.Scanner.Biz.twain32.form;

namespace HXX.Scanner.Biz
{
    /// <summary>
    /// tw基本类
    /// </summary>
    public class engine_twain32
    {
        public engine_twain32(Form _main, ApplicationSettingsBase config, del_change_sanner _method)
        {
            universe = new biz_thread();
            universe.start();

            biz_changeScan.change_scanner = _method;
            config_manager.Init(config);
            current_object = this;
            main_window = _main;
        }

        /// <summary>
        /// 类基本实体
        /// </summary>
        private static engine_twain32 current_object;
        /// <summary>
        /// tw所运行的消息循环线程
        /// </summary>
        private static biz_thread universe;
        /// <summary>
        /// 外部调用窗体，废弃
        /// </summary>
        private static Form main_window;
        /// <summary>
        /// 本实体对外引用
        /// </summary>
        public static engine_twain32 Engine
        {
            get
            {
                return current_object;
            }
        }

        /// <summary>
        /// 刷新扫描仪列表（仅tw自身所见）
        /// </summary>
        public void load_tw_scanner_list()
        {
            try
            {
                universe.frm_handler.Invoke(new Action(() =>
                {
                    try
                    {
                        universe.engine.CloseDataSource();
                        universe.engine.CloseDSM();

                        var result_scan = universe.engine.OpenDSM();

                        scanner_manager.Clear();
                        List<Device_Scanner> temp_list = new List<Device_Scanner>();

                        for (int i = 0; i < universe.engine.SourcesCount; i++)
                        {
                            //TODO 判断设备类型,有可能把摄像头给加载进来了// 支持2.0及以上的，才加载进来
                            if (universe.engine.GetIsSourceTwain2Compatible(i))
                            {
                                var scanner = new Device_Scanner(universe.engine.GetSourceProductName(i))
                                {
                                    dsIndex = i
                                };

                                biz_property_engine_to_scanner.Set(universe.engine, scanner);
                                temp_list.Add(scanner);
                            }
                        }

                        add_scanner(temp_list, "canon");
                        add_scanner(temp_list, "panasonic");
                        add_scanner(temp_list, "kodak");
                        add_scanner(temp_list, "huago");
                        add_scanner(temp_list, "epson");
                        add_scanner(temp_list, "hp");
                        add_scanner(temp_list, "fi");
                    }
                    catch (Exception ee)
                    {
                        LogManager.WriteLog(ee);
                    }
                }));
            }
            catch (Exception ex)
            {
                LogManager.WriteLog(ex);
            }
        }

        /// <summary>
        /// 添加一台扫描仪
        /// </summary>
        /// <param name="list"></param>
        /// <param name="name"></param>
        private void add_scanner(List<Device_Scanner> list, string name)
        {
            if (name == "huago")
            {
                foreach (var scanner in list)
                {
                    if (scanner.deviceName.ToLower().Contains(name))
                    {
                        scanner_manager.Add(scanner);
                    }
                }
            }
            else
            {
                var scanner = list.FirstOrDefault(x => x.deviceName.ToLower().Contains(name));

                if (scanner != null)
                {
                    scanner_manager.Add(scanner);
                }
            }
        }

        /// <summary>
        /// 调用第三方弹框扫描
        /// </summary>
        /// <param name="scanner"></param>
        public void Scan_pop(Device_Scanner scanner)
        {
            Task.Run(async () =>
            {
                try
                {
                    biz_dynam.kill_process();
                    //var biz = new biz_pop();
                    var biz = new biz_pop2();

                    try
                    {
                        config_environment.scan_state = true;
                        config_environment.scan_state_socket = true;
                        universe.engine.CloseDataSource();

                        //biz.scan(scanner.dsIndex);
                        biz.scan(scanner, main_window);
                    }
                    catch (Exception ee)
                    {
                        if (ee.Message.Contains("cancelled"))
                        {
                            biz_scanFinishBatch.Work(4, true);
                        }
                        else
                        {
                            LogManager.WriteLog(ee);
                        }
                    }

                    //biz.close();
                    //biz_dynam.kill_process();

                    biz_scanFinishBatch.Work(5, true);
                    scanner_manager.set_current(-1);
                    await set_current(scanner);
                    biz_scanFinishBatch.Work(6, true);

                    config_environment.scan_state = false;
                    config_environment.scan_state_socket = false;
                }
                catch (Exception ee)
                {
                    LogManager.WriteLog(ee);
                }
            });
        }

        /// <summary>
        /// 普通扫描
        /// </summary>
        /// <param name="scanner"></param>
        /// <returns></returns>
        public async Task<ResponseEntity> Scan(Device_Scanner scanner)
        {
            ResponseEntity result = new ResponseEntity();
            biz_engine_side.check_all();
            biz_dynam.kill_process();

            result = biz_disk.check_disk_status();

            if (result.Status == 200 || result.Status == 510)
            {
                result = await check_status_scan();

                if (result.Status == 200)
                {
                    result = await set_current(scanner);

                    if (result.Status == 1)
                    {
                        http_manager.ready_list.Clear();

                        if (!config_environment.use_source_ui)
                        {
                            biz_engine_prepare.prepare();

                            biz_property_scanner_to_engine.Set(universe.engine, scanner);
                            file_manager.temp_count = 0;

                            universe.frm_handler.Invoke(new Action(() =>
                            {
                                universe.engine.Acquire();

                                //if (config_environment.use_source_ui)
                                //{
                                //    //biz_engine_side.active_3rd_form(main_window);
                                //    biz_engine_side.active_3rd_form(universe.frm_handler);
                                //}
                            }));
                        }
                        else
                        {
                            Scan_pop(scanner);
                        }

                        result.Status = 1;
                        result.Message = "ok";
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 激活扫描仪
        /// </summary>
        /// <param name="scanner"></param>
        /// <returns></returns>
        public async Task<ResponseEntity> set_current(Device_Scanner scanner)
        {
            ResponseEntity result = new ResponseEntity();
            biz_engine_side.check_all();
            biz_dynam.kill_process();

            try
            {
                if (scanner != null)
                {
                    //if (!scanner.openSourceReady || !await check_online())
                    if (!scanner.openSourceReady)
                    {
                        result = await Task.Run(() => { return set_current_method(scanner); });

                        if (result.Status == 1)
                        {
                            scanner_manager.set_current(scanner.dsIndex);
                        }
                    }

                    //if (scanner.openSourceReady && await check_online())
                    if (scanner.openSourceReady)
                    {
                        result.Status = 1;
                        result.Message = "ok";
                    }
                    else
                    {
                        scanner_manager.set_current(-1);
                        result.Status = 0;
                        result.Message = "未正常连接扫描设备";
                    }
                }
                else
                {
                    scanner_manager.set_current(-1);
                    result.Status = 0;
                    result.Message = "请选择扫描设备";
                }
            }
            catch (Exception ee)
            {
                scanner_manager.set_current(-1);

                if (!ee.Message.Contains("DS or DSM reported error, application shouldn't"))
                {
                    LogManager.WriteLog(ee);
                }

                result.Status = 0;
                result.Message = "扫描设备连接失败";
            }

            return result;
        }

        /// <summary>
        /// 激活扫描仪 具体业务
        /// </summary>
        /// <param name="scanner"></param>
        /// <returns></returns>
        private ResponseEntity set_current_method(Device_Scanner scanner)
        {
            ResponseEntity result = new ResponseEntity();

            try
            {
                universe.frm_handler.Invoke(new Action(() =>
                {
                    try
                    {
                        universe.engine.CloseDataSource();
                        universe.engine.SourceIndex = scanner.dsIndex;

                        if (universe.engine.OpenDataSource())
                        {
                            universe.engine.SetCap(TwCap.Indicators, false);

                            result.Status = 1;
                            result.Message = "ok";
                        }
                    }
                    catch (Exception ee)
                    {
                        scanner_manager.set_current(-1);

                        if (ee.Message.Contains("DG") || ee.Message.Contains("正在中止线程"))
                        {
                            result.Status = -1;
                        }
                        else
                        {
                            if (!ee.Message.Contains("DS or DSM reported error, application shouldn't"))
                            {
                                LogManager.WriteLog(ee);
                            }

                            result.Status = 0;
                            result.Message = "扫描设备连接失败";
                        }
                    }
                }));
            }
            catch (Exception ee)
            {
                scanner_manager.set_current(-1);

                if (ee.Message.Contains("DG") || ee.Message.Contains("正在中止线程"))
                {
                    result.Status = -1;
                }
                else
                {
                    if (!ee.Message.Contains("DS or DSM reported error, application shouldn't"))
                    {
                        LogManager.WriteLog(ee);
                    }

                    result.Status = 0;
                    result.Message = "扫描设备连接失败";
                }
            }

            return result;
        }

        //private async Task<bool> check_online()
        //{
        //    ResponseEntity<bool> result = new ResponseEntity<bool>();
        //    var timeout = 2000;

        //    Thread t = new Thread(() =>
        //    {
        //        var r = check_online_method();
        //        result.Status = 1;
        //        result.Message = "ok";
        //        result.Data = r;
        //    });

        //    t.Start();

        //    Stopwatch sw = new Stopwatch();
        //    sw.Start();

        //    await Task.Run(() =>
        //    {
        //        while (true)
        //        {
        //            try
        //            {
        //                if (result.Status == 1)
        //                {
        //                    break;
        //                }
        //                else
        //                {
        //                    if (sw.ElapsedMilliseconds > timeout)
        //                    {
        //                        result.Status = 0;
        //                        result.Message = "timeout";
        //                        t.Abort();

        //                        break;
        //                    }
        //                    else
        //                    {
        //                        Thread.Sleep(100);
        //                    }
        //                }
        //            }
        //            catch
        //            {
        //                result.Status = 0;
        //                result.Message = "exception";
        //                break;
        //            }
        //        }
        //    });

        //    bool f = false;

        //    if (result.Status == 1)
        //    {
        //        f = result.Data;
        //    }
        //    else
        //    {
        //        f = false;
        //    }

        //    //if (!f)
        //    //{
        //    //    scanner_manager.set_current(-1);
        //    //}

        //    return f;
        //}

        //private bool check_online_method()
        //{
        //    //while (true) ;
        //    bool result = false;

        //    //frm_handler.Invoke(new Action(() =>
        //    //{
        //    try
        //    {
        //        var obj = universe.engine.GetCap(TwCap.DeviceOnline);

        //        var r1 = obj as Twain32.Enumeration;
        //        var r2 = obj as bool?;

        //        if (r1 != null)
        //        {
        //            if ((bool)r1[r1.CurrentIndex])
        //            {
        //                result = true;
        //            }
        //        }
        //        else
        //        {
        //            if (r2 == true)
        //            {
        //                result = true;
        //            }
        //        }
        //    }
        //    catch (Exception ee2) { }
        //    //}));

        //    return result;
        //}

        //private async Task<bool> check_paper()
        //{
        //    ResponseEntity<bool> result = new ResponseEntity<bool>();
        //    var timeout = 2000;

        //    Thread t = new Thread(() =>
        //    {
        //        var r = check_paper_method();
        //        result.Status = 1;
        //        result.Message = "ok";
        //        result.Data = r;
        //    });

        //    t.Start();

        //    Stopwatch sw = new Stopwatch();
        //    sw.Start();

        //    await Task.Run(() =>
        //    {
        //        while (true)
        //        {
        //            try
        //            {
        //                if (result.Status == 1)
        //                {
        //                    break;
        //                }
        //                else
        //                {
        //                    if (sw.ElapsedMilliseconds > timeout)
        //                    {
        //                        result.Status = 0;
        //                        result.Message = "timeout";
        //                        t.Abort();

        //                        break;
        //                    }
        //                    else
        //                    {
        //                        Thread.Sleep(100);
        //                    }
        //                }
        //            }
        //            catch
        //            {
        //                result.Status = 0;
        //                result.Message = "exception";
        //                break;
        //            }
        //        }
        //    });

        //    if (result.Status == 1)
        //    {
        //        return result.Data;
        //    }
        //    else
        //    {
        //        return false;
        //    }
        //}

        /// <summary>
        /// 检查是否卡纸
        /// </summary>
        /// <returns></returns>
        private bool check_paper_method()
        {
            bool result = false;

            //frm_handler.Invoke(new Action(() =>
            //{
            try
            {
                var obj = universe.engine.GetCap(TwCap.FeederLoaded);

                var r1 = obj as Twain32.Enumeration;
                var r2 = obj as bool?;

                if (r1 != null)
                {
                    if ((bool)r1[r1.CurrentIndex])
                    {
                        result = true;
                    }
                }
                else
                {
                    if (r2 == true)
                    {
                        result = true;
                    }
                }
            }
            catch (Exception ee2) { }
            //}));

            return result;
        }

        ///// <summary>
        ///// 
        ///// </summary>
        ///// <param name="code"></param>
        ///// <returns></returns>
        //public ResponseEntity check_engine_status(bool is_heartbeat)
        //{
        //    ResponseEntity result = new ResponseEntity();

        //    if (config_environment.scan_state)
        //    {
        //        if (is_heartbeat)
        //        {
        //            if (!check_paper())
        //            {
        //                result.Status = 502;
        //                result.Message = "未检测到纸张或卡纸";
        //            }
        //            else
        //            {
        //                result.Status = 201;
        //                result.Message = "扫描仪正在使用中";
        //            }
        //        }
        //        else
        //        {
        //            result.Status = 201;
        //            result.Message = "扫描仪正在使用中";
        //        }
        //    }
        //    else
        //    {
        //        try
        //        {
        //            if (!check_online())
        //            {
        //                result.Status = 501;
        //                result.Message = "扫描仪未连接";
        //            }
        //            else
        //            {
        //                if (is_heartbeat)
        //                {
        //                    result.Status = 200;
        //                    result.Message = "扫描仪就绪";
        //                }
        //                else
        //                {
        //                    if (!check_paper())
        //                    {
        //                        result.Status = 502;
        //                        result.Message = "未检测到纸张或卡纸";
        //                    }
        //                    else
        //                    {
        //                        result.Status = 200;
        //                        result.Message = "扫描仪就绪";
        //                    }
        //                }
        //            }
        //        }
        //        catch (Exception ee)
        //        {
        //            if (ee.Message.Contains("Источник данных не открыт"))
        //            {
        //                result.Status = 501;
        //                result.Message = "扫描仪未连接";
        //            }
        //            else
        //            {
        //                result.Status = 509;
        //                result.Message = ee.Message;
        //            }
        //        }
        //    }

        //    return result;
        //}

        /// <summary>
        /// 初始化状态
        /// </summary>
        public static bool first_state = false;

        /// <summary>
        /// 检查当前状态，心跳用
        /// </summary>
        /// <returns></returns>
        public ResponseEntity check_status_heartbeat()
        {
            ResponseEntity result = new ResponseEntity();

            if (config_environment.on_error == null ||
                (config_environment.on_error.Status == 1 ||
                result.Status == -1 ||
                result.Status == 200))
            {
                if (config_environment.scan_state == false && config_environment.scan_state_socket == true && first_state)
                {
                    Task.Run(() =>
                    {
                        Thread.Sleep(3000);
                        config_environment.scan_state_socket = false;
                        first_state = false;
                    });
                }

                if (config_environment.scan_state_socket)
                {
                    result.Status = 201;
                    result.Message = "扫描仪正在使用中";
                }
                else
                {
                    //result.Status = 200;
                    //result.Message = "扫描仪就绪";

                    //try
                    {
                        //if (!await check_online().ConfigureAwait(false))
                        if (!check_online_v2())
                        {
                            result.Status = 501;
                            result.Message = "扫描仪未连接";
                        }
                        else
                        {
                            result.Status = 200;
                            result.Message = "扫描仪就绪";
                        }
                    }
                    //catch (Exception ee)
                    //{
                    //    if (ee.Message.Contains("Источник данных не открыт"))
                    //    {
                    //        result.Status = 501;
                    //        result.Message = "扫描仪未连接";
                    //    }
                    //    else
                    //    {
                    //        result.Status = 509;
                    //        result.Message = ee.Message;
                    //    }
                    //}
                }
            }
            else
            {
                result.Status = 509;
                result.Message = config_environment.on_error.Message;

                config_environment.on_error = null;
            }

            return result;
        }

        /// <summary>
        /// 检查当前状态，扫描用
        /// </summary>
        /// <returns></returns>
        public async Task<ResponseEntity> check_status_scan()
        {
            ResponseEntity result = new ResponseEntity();

            if (config_environment.scan_state)
            {
                result.Status = 201;
                result.Message = "扫描仪正在使用中";
            }
            else
            {
                try
                {
                    //if (!await check_online())
                    //if (!check_online_method())
                    //{
                    //    result.Status = 501;
                    //    result.Message = "扫描仪未连接";
                    //}
                    //else
                    {
                        //if (!await check_paper())
                        if (!check_paper_method())
                        {
                            result.Status = 502;
                            result.Message = "未检测到纸张或卡纸";
                        }
                        else
                        {
                            result.Status = 200;
                            result.Message = "扫描仪就绪";
                        }
                    }
                }
                catch (Exception ee)
                {
                    if (ee.Message.Contains("Источник данных не открыт"))
                    {
                        result.Status = 501;
                        result.Message = "扫描仪未连接";
                    }
                    else
                    {
                        result.Status = 509;
                        result.Message = ee.Message;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 检查当前状态，界面用
        /// </summary>
        /// <returns></returns>
        public async Task<ResponseEntity> check_status_ui()
        {
            ResponseEntity result = new ResponseEntity();

            if (config_environment.scan_state)
            {
                result.Status = 201;
                result.Message = "扫描仪正在使用中";
            }
            else
            {
                try
                {
                    //if (!await check_online().ConfigureAwait(false))
                    if (!check_online_v2())
                    {
                        result.Status = 501;
                        result.Message = "扫描仪未连接";
                    }
                    else
                    {
                        result.Status = 200;
                        result.Message = "扫描仪就绪";
                    }
                }
                catch (Exception ee)
                {
                    if (ee.Message.Contains("Источник данных не открыт"))
                    {
                        result.Status = 501;
                        result.Message = "扫描仪未连接";
                    }
                    else
                    {
                        result.Status = 509;
                        result.Message = ee.Message;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 检查扫描仪激活情况
        /// </summary>
        /// <returns></returns>
        public bool check_online_v2()
        {
            return scanner_manager.Scanner_List.Count(x => x.isActive == 1) > 0;
        }
    }
}