using HH.Redis.ReisModel;
using HH.WMS.BLL;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Func;
using HH.WMS.Entitys.Sys;
using HH.WMS.WebApi.Areas.Common.Controllers;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Web.Configuration;
using System.Web.Http;

namespace HH.WMS.WebApi.Areas.Basic
{
    public class StrategyController : BaseController
    {
        #region PDA接口：获取策略
        /// <summary>
        /// PDA接口：获取策略
        /// </summary>
        /// <returns></returns>
        /// <history>[HanHe(xdl)] CREATED 2018/11/13</history>
        [HttpGet]
        public OperateResult GetStrategys()
        {
            return ValidateToken(x =>
            {
                try
                {
                    //string json = HH.WMS.Common.WebApiManager.HttpAutoBom_Get("api/Configure/GetListByApp?AppCode=WMS");
                    //json = "[" + json + "]";
                    //DataTable dt = JsonConvert.DeserializeObject<DataTable>(json);
                    //return JsonConvert.SerializeObject(OperateResult.Succeed("", dt));

                    if (SysCache.SysStrategy == null || SysCache.SysStrategy.Count == 0)
                        SysCache.SysStrategy = BLLCreator.Create<DapperBLL<TN_WM_B_STRATEGY_VALUEEntity>>().GetList();
                    return OperateResult.Succeed(null, SysCache.SysStrategy);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error("策略获取异常！" + ex.ToString());
                }
            });
        }
        #endregion

        #region 获取所有策略
        /// <summary>
        /// 获取所有策略
        /// </summary>
        /// <param name="tokenId"></param>
        /// <returns></returns>
        /// <history>[HanHe(dbs)] CREATED 2018/11/19</history>
        [HttpGet]
        public OperateResult GetSysSetList()
        {
            return ValidateToken(x =>
            {
                try
                {
                    List<TN_WM_B_STRATEGY_DEFEntity> entity = BLLCreator.Create<TN_WM_B_STRATEGY_DEFBLL>().GetStrategyList();
                    return OperateResult.Succeed("", entity);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error("查询异常！" + ex.ToString());
                }
            });
        }
        #endregion

        #region 获取仓库下的策略值
        /// <summary>
        /// 获取仓库下的策略值
        /// </summary>
        /// <param name="tokenId"></param>
        /// <param name="stockCode">仓库编号</param>
        /// <returns></returns>
        /// <history>[HanHe(dbs)] CREATED 2018/11/19</history>
        [HttpGet]
        public OperateResult GetOptionValue(string stockCode)
        {
            return ValidateToken(x =>
            {
                try
                {
                    List<TN_WM_B_STRATEGY_VALUEEntity> entity = BLLCreator.Create<DapperBLL<TN_WM_B_STRATEGY_VALUEEntity>>().GetList(new { CN_S_STOCK_CODE = stockCode });
                    return OperateResult.Succeed("", entity);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error("查询异常！" + ex.ToString());
                }
            });
        }
        #endregion

        #region 保存更新变更的策略
        /// <summary>
        /// 保存更新变更的策略
        /// </summary>
        /// <param name="tokenId">tokenID</param>
        /// <param name="stockCode">仓库编号</param>
        /// <param name="ChangedItems">变更项</param>
        /// <returns></returns>
        /// <history>[HanHe(dbs)] CREATED 2018/11/19</history>
        [HttpGet]
        public OperateResult Save(string stockCode, string ChangedItems)
        {
            return ValidateToken(x =>
            {
                try
                {
                    List<TN_WM_B_STRATEGY_DEFEntity> list = JsonConvert.DeserializeObject<List<TN_WM_B_STRATEGY_DEFEntity>>(ChangedItems);
                    list.ForEach(p =>
                    {
                        p.CN_S_MODIFY = p.CN_S_CREATOR = x.CN_S_LOGIN;
                        p.CN_S_MODIFY_BY = p.CN_S_CREATOR_BY = x.CN_S_NAME;
                    });

                    OperateResult result = BLLCreator.Create<TN_WM_B_STRATEGY_VALUEBLL>().UpdateSetValue(stockCode, list);
                    if (result.Status == ResultStatus.Success)
                    {
                        foreach (TN_WM_B_STRATEGY_DEFEntity n in list)
                        {
                            var v = SysCache.SysStrategy.Find(m => m.CN_S_STOCK_CODE.Equals(stockCode) && m.CN_S_CODE.Equals(n.CN_S_CODE));
                            if (v == null)
                                SysCache.SysStrategy.Add(new TN_WM_B_STRATEGY_VALUEEntity()
                                {
                                    CN_S_STOCK_CODE = stockCode,
                                    CN_S_CODE = n.CN_S_CODE,
                                    CN_S_VALUE = n.CN_S_VALUE
                                });
                            else
                            {
                                v.CN_S_VALUE = n.CN_S_VALUE;
                            }
                        }
                    }
                    return result;
                }
                catch (Exception ex)
                {
                    return OperateResult.Error("更新异常！" + ex.ToString());
                }
            });
        }
        #endregion

        #region 获取库区下所有策略
        /// <summary>
        /// 获取库区下所有策略
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        /// <history>[HanHe(xdl)] CREATED 2018/12/05</history>
        [HttpGet]
        public OperateResult GetStrategyList(string areaCode)
        {
            return ValidateToken(x =>
            {
                try
                {
                    DataTable dt = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetStrategyList(areaCode);
                    return OperateResult.Succeed(null, dt);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 获取库区所有没设置的策略
        /// <summary>
        /// 获取库区所有没设置的策略
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        public OperateResult GetNoStrategyList(string areaCode)
        {
            return ValidateToken(x =>
            {
                try
                {
                    DataTable dt = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetNoStrategyList(areaCode);
                    return OperateResult.Succeed(null, dt);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }

        #endregion

        #region 更新优先级
        /// <summary>
        /// 更新优先级
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <param name="stockCode">仓库编码</param>
        /// <param name="strategyGuid">策略Guid</param>
        /// <param name="priority">优先级</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult UpdatePriority(string areaCode, string stockCode, string strategyGuid, string priority)
        {
            return ValidateToken(x =>
            {
                try
                {
                    if (string.IsNullOrEmpty(areaCode)) areaCode = "";

                    OperateResult result = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().UpdatePriority(areaCode, stockCode, strategyGuid, priority);
                    return result;
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 删除库区策略
        /// <summary>
        /// 删除库区策略
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <param name="stockCode">仓库编码</param>
        /// <param name="strategyGuid">策略Guid</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult DeleteAreaStrategy(string areaCode, string stockCode, string strategyGuid)
        {
            return ValidateToken(x =>
            {
                try
                {
                    if (string.IsNullOrEmpty(areaCode)) areaCode = "";

                    OperateResult result = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().DeleteAreaStrategy(areaCode, stockCode, strategyGuid);
                    return result;
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 保存库区策略关联
        /// <summary>
        /// 保存库区策略关联
        /// </summary>
        /// <param name="jsonStr">数据集合</param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult SaveStrategyUse(JObject jsonStr)
        {
            string tokenId = jsonStr.Value<string>("TokenId");
            return ValidateToken(tokenId, x =>
            {
                try
                {
                    string strategyGuid = jsonStr.Value<string>("selectValue");
                    string areaCode = jsonStr.Value<string>("areaCode");
                    string stockCode = jsonStr.Value<string>("stockCode");

                    if (string.IsNullOrEmpty(stockCode) && string.IsNullOrEmpty(areaCode))
                    {
                        return OperateResult.Error("参数缺失！");
                    }
                    OperateResult result = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().SaveStrategyUse(strategyGuid, areaCode, stockCode);
                    return result;
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 根据库区编码和策略类型获取策略
        /// <summary>
        /// 根据库区编码和策略类型获取策略，策略类型选填（三生物料上架PDA接口）
        /// </summary>
        /// <param name="areaCode">库区编码</param>
        /// <param name="strategyType">策略类型</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetStrategyType(string areaCode, string strategyType)
        {
            return ValidateToken(x =>
            {
                try
                {
                    DataTable dt = BLLCreator.Create<TN_WM_B_STRATEGYBLL>().GetStrategyType(areaCode, strategyType);
                    return OperateResult.Succeed(null, dt);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        #region 获取配置文件
        public OperateResult GetWebConfig()
        {
            //return ValidateToken(x =>
            //{
                try
                {
                    //List<TN_WM_SYS_CONFIGEntity> list = BLLCreator.Create<DapperBLL<TN_WM_SYS_CONFIGEntity>>().GetList();
                    //foreach (TN_WM_SYS_CONFIGEntity m in list)
                    //{
                    //    if (Constants.config.ContainsKey(m.CN_S_KEY))
                    //        Constants.config[m.CN_S_KEY] = m.CN_S_VALUE;
                    //    else
                    //        Constants.config.Add(m.CN_S_KEY, m.CN_S_VALUE);
                    //}

                    SysConfigParamEntity v = new SysConfigParamEntity()
                     {
                         DB_TYPE = ConfigurationManager.ConnectionStrings["DataType"].ConnectionString,
                         DB_URL = ConfigurationManager.ConnectionStrings["wmsConnection"].ConnectionString.Replace('\\', '*'),

                         REDIS = Util.ToString(ConfigurationManager.AppSettings["RedisPath"]),
                         REDIS_DB = Util.ToString(ConfigurationManager.AppSettings["DefaultDb"]),

                         MIP = ConfigurationManager.ConnectionStrings["MIP"].ConnectionString,
                         MPORT = ConfigurationManager.ConnectionStrings["MPORT"].ConnectionString,
                         MDB = ConfigurationManager.ConnectionStrings["MDB"].ConnectionString,
                         MUSER = ConfigurationManager.ConnectionStrings["MUSER"].ConnectionString,
                         MPWD = ConfigurationManager.ConnectionStrings["MPWD"].ConnectionString,

                         UI_ROOT_PATH =Util.ToString(ConfigurationManager.AppSettings["UI_ROOT_PATH"]).Replace('\\', '*'),
                         APP_CODE = Util.ToString(ConfigurationManager.AppSettings["AppCode"]),
                         APP_NAME = Util.ToString(ConfigurationManager.AppSettings["AppName"]),
                         AUTOBOM = Util.ToString(ConfigurationManager.AppSettings["autobom_ipAddress"]),
                         KdEID = Util.ToString(ConfigurationManager.AppSettings["KdEID"]),
                         KdEAppKey = Util.ToString(ConfigurationManager.AppSettings["KdEAppKey"]),
                         KdEReqURL = Util.ToString(ConfigurationManager.AppSettings["KdEReqURL"]),
                         PdaServerVersion = Util.ToString(ConfigurationManager.AppSettings["PdaServerVersion"]),
                         PdalastForce = Util.ToString(ConfigurationManager.AppSettings["PdalastForce"]),
                         PdaTitle = Util.ToString(ConfigurationManager.AppSettings["PdaTitle"]),
                         PdaUpdateUrl = Util.ToString(ConfigurationManager.AppSettings["PdaUpdateUrl"]),
                         OMS_API = Util.ToString(ConfigurationManager.AppSettings["OMS_API"]),
                         AMS_API = Util.ToString(ConfigurationManager.AppSettings["ams_ipAddress"]),
                         PROJECT_CODE = Util.ToString(ConfigurationManager.AppSettings["projectCode"])
                     };
                    Constants.SysConfig = v;
                    return OperateResult.Succeed("", v);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            //});
        }
        #endregion
        //[HttpPost]
        //public OperateResult SaveWmsApi(SysConfigParamEntity model)
        //{
        //    if (Constants.config.ContainsKey("CN_S_WMS_API"))
        //        Constants.config["CN_S_WMS_API"] = model.WMS_API;
        //    else
        //        Constants.config.Add("CN_S_WMS_API", model.CN_S_WMS_API);
        //    return OperateResult.Succeed();
        //}
        [HttpPost]
        public OperateResult SaveWebConfig(SysConfigParamEntity model)
        {
            config = WebConfigurationManager.OpenWebConfiguration(System.Web.HttpContext.Current.Request.ApplicationPath);

            SetAppSettingsSection("AppCode", model.APP_CODE);
            SetAppSettingsSection("AppName", model.APP_NAME);

            SetAppSettingsSection("autobom_ipAddress", model.AUTOBOM);

            //SetAppSettingsSection("DB_TYPE", model.DB_TYPE);
            //SetAppSettingsSection("DB_URL", model.DB_URL.Replace('*', '\\'));

            SetAppSettingsSection("RedisPath", model.REDIS);
            SetAppSettingsSection("DefaultDb", model.REDIS_DB);
            //SetAppSettingsSection("MIP", model.MIP);
            //SetAppSettingsSection("MPORT", model.MPORT);
            //SetAppSettingsSection("MPWD", model.MPWD);
            //SetAppSettingsSection("MUSER", model.MUSER);
            //SetAppSettingsSection("MDB", model.MDB);
            SetAppSettingsSection("UI_ROOT_PATH", model.UI_ROOT_PATH.Replace('*', '\\'));

            SetAppSettingsSection("KdEID", model.KdEID);
            SetAppSettingsSection("KdEAppKey", model.KdEAppKey);
            SetAppSettingsSection("KdEReqURL", model.KdEReqURL);
            SetAppSettingsSection("PdaServerVersion", model.PdaServerVersion);
            SetAppSettingsSection("PdalastForce", model.PdalastForce);
            SetAppSettingsSection("PdaUpdateUrl", model.PdaUpdateUrl);

            SetAppSettingsSection("OMS_API", model.OMS_API);
            SetAppSettingsSection("ams_ipAddress", model.AMS_API);

            SetConnectionStringsSection("wmsConnection", model.DB_URL.Replace('*', '\\'), "System.Data.SqlClient");
            SetConnectionStringsSection("DataType", model.DB_TYPE, "");
            SetConnectionStringsSection("MIP", model.MIP, "");
            SetConnectionStringsSection("MPORT", model.MPORT, "");
            SetConnectionStringsSection("MDB", model.MDB, "");
            SetConnectionStringsSection("MUSER", model.MUSER, "");
            SetConnectionStringsSection("MPWD", model.MPWD, "");

            Constants.SysConfig = model;
            return OperateResult.Succeed();
        }
        Configuration config;
        public void SetConnectionStringsSection(string name, string ConnectionString, string providerName)
        {
            ConnectionStringsSection conSection = (ConnectionStringsSection) config.GetSection("connectionStrings");
            if (conSection.ConnectionStrings[name] != null)
            {
                if (conSection.ConnectionStrings[name].ConnectionString != ConnectionString)
                {
                    conSection.ConnectionStrings[name].ConnectionString = ConnectionString;
                    if (providerName.Length > 0)
                        conSection.ConnectionStrings[name].ProviderName = providerName;
                    config.Save();
                }
            }
            else
            {
                ConnectionStringSettings conSettings = new ConnectionStringSettings(name, ConnectionString, providerName);
                conSection.ConnectionStrings.Add(conSettings);
                config.Save();
            }
        }

        public void SetAppSettingsSection(string key, string value)
        {
            AppSettingsSection appSettings = (AppSettingsSection)config.GetSection("appSettings");
            if (appSettings.Settings[key] != null)
            {
                if (appSettings.Settings[key].Value != value)
                {
                    appSettings.Settings[key].Value = value;
                    config.Save();
                }
            }
            else
            {
                appSettings.Settings.Add(key, value);
                config.Save();
            }
        }

        #region 检测数据库是否连接正常
        [HttpGet]
        public OperateResult TestDb(string dbUrl, string dbType)
        {
            dbUrl = System.Web.HttpUtility.UrlDecode(dbUrl);
            try
            {
                switch (dbType)
                {
                    case "MSSQL":
                        SqlConnection m_myConnection = new SqlConnection(dbUrl);
                        m_myConnection.Open();
                        //数据库操作...... 
                        m_myConnection.Close();
                        break;
                    case "MYSQL":
                        break;
                }
                return OperateResult.Succeed("");
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion
        [HttpGet]
        public OperateResult TestIpPort(string ipPort)
        {
            TcpClient client = new TcpClient();
            try
            {
                var ar = client.BeginConnect(ipPort.Split(':')[0],Convert.ToInt32(ipPort.Split(':')[1]), null, null);
                ar.AsyncWaitHandle.WaitOne(2000);
                if (client.Connected)
                    return OperateResult.Succeed();
                else
                    return OperateResult.Error();
            }
            catch (Exception e)
            {
                return OperateResult.Error();
            }
            finally
            {
                client.Close();
            }
        }
        public OperateResult TestConnection(string host, int port, int millisecondsTimeout)
        {
            TcpClient client = new TcpClient();
            try
            {
                var ar = client.BeginConnect(host, port, null, null);
                ar.AsyncWaitHandle.WaitOne(millisecondsTimeout);
                if (client.Connected)
                    return OperateResult.Succeed();
                else
                    return OperateResult.Error();
            }
            catch (Exception e)
            {
                return OperateResult.Error();
            }
            finally
            {
                client.Close();
            }
        } 
    }
}