using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using GThinking.N_MISPRO.Data;
using GThinking.N_MODEL.Page;
using GThinking.N_MISPRO;
using GThinking.N_CONTROL;
using GThinking.N_MISPRO.Utility;
using System.Collections.Generic;
using GThinking.N_MISPRO.Caching;

namespace GThinking.N_XLXSBJ
{
    public partial class JGBML_TJYZList : SingleGridBase
    {
        JGBML_TJYZ entity = new JGBML_TJYZ();

        protected void Page_Load(object sender, EventArgs e)
        {
            this.UMID = 100860018;
            this.UMName = "线缆销售报价价格目录";
            this.CurMaster = Master;
            this.ModuleGV = ContentGrid;
            this.CurEntity = entity;
            //this.CurQueryEntity = queryentity;
            this.PageHeight = 600;
            this.PageWidth = 750;
            //this.sURLTarget = "JGBMLInfo.aspx";
            //this.sQueryURLTarget = "JGBMLQuery.aspx";
            base.DataKeyNames = new string[] { "YZID" };
            Master.EnableNewBtn = false;
            Master.EnableCopyBtn = false;
            Master.EnableViewBtn = false;
            Master.EnableEditBtn = false;
            Master.EnableDeleteBtn = false;
            Master.EnableQueryBtn = false;

            base.InitPage();

            if (!IsPostBack)
            {
                InitJSGS();
                Master_OnStandardQuery(null, null);
            }
        }

        #region 模板继承事件

        protected override void Master_OnStandardQuery(object sender, EventArgs e)
        {
            //base.InitEntityByCondition();
            base.Master_OnStandardQuery(sender, e);
            entity.EntityTable.QuerySelSql = GetQuerySql();
            entity.GridDataBind(ContentGrid, tSession);
        }

        protected override void moduleGV_PageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            //base.InitEntityByCondition();
            entity.EntityTable.QuerySelSql = GetQuerySql();
            ContentGrid.SelectedIndex = -1;
            base.moduleGV_PageIndexChanging(sender, e);
        }

        #endregion

        #region 自定义方法

        private string GetQuerySql()
        {
            string sSQL = " select XLXSTZYZ_YZID as YZID,XLXSTZYZ_YZMC as YZMC,"
                         + "  case when XLXSJGBYZ_YZID is null then 'N' else 'Y' end as SY,"
                         + "  case when XLXSJGBYZ_YZID is null then XLXSTZYZ_BZ else XLXSJGBYZ_BZ end as BZ,"
                         + "  case when XLXSJGBYZ_YZID is null then XLXSTZYZ_WHRID else XLXSJGBYZ_WHRID end as WHRID,"
                         + "  case when XLXSJGBYZ_YZID is null then XLXSTZYZ_WHR else XLXSJGBYZ_WHR end as WHR,"
                         + "  case when XLXSJGBYZ_YZID is null then XLXSTZYZ_WHSJ else XLXSJGBYZ_WHSJ end as WHSJ"
                        + " from XLXSTZYZ left join XLXSJGBYZ on XLXSJGBYZ_JGBID=:pJGBID and XLXSJGBYZ_YZID=XLXSTZYZ_YZID"
                        //2 ,6是损耗，统一不可用
                        + " where XLXSTZYZ_MXBH='JZJ' and XLXSTZYZ_TJYS<>'2' and XLXSTZYZ_TJYS<>'6' and XLXSTZYZ_TJYS<>'7' ";
                       
            entity.Param.Add("pJGBID", PageParam.GetRTrimString("JGBID"));
            if (XLBJDUtils.IsJGEJGB(PageParam.GetRTrimString("JGBID")))
            {
                //JGE类型暂时不可设置区域导致因素无效-3销售区域&导体材料&线缆型号&主芯截面
                //sSQL += " and XLXSTZYZ_TJYS<>'3' ";
            }
            sSQL += " order by XLXSTZYZ_XSXH,XLXSTZYZ_YZID";
            return sSQL;
        }

        private void InitJSGS()
        {
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add("select isnull(XLXSJGB_JSGS,' ') as XLXSJGB_JSGS from XLXSJGB where XLXSJGB_JGBID=:pJGBID ");
            SQL.ParamByName("pJGBID").Value = PageParam.GetRTrimString("JGBID");
            DataSet ds = dberp.OpenDataSet(SQL);
            if (ds.Tables[0].Rows.Count > 0)
                txtJSGS.Text = ConvertCodeToName(ds.Tables[0].Rows[0]["XLXSJGB_JSGS"].ToString().Trim());
        }

        private Dictionary<string, string> GetYZIDNameMap()
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add("select XLXSTZYZ_YZID from XLXSTZYZ where XLXSTZYZ_MXBH='JZJ' ");
            DataSet ds = dberp.OpenDataSet(SQL);
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                string sYZID = ds.Tables[0].Rows[i]["XLXSTZYZ_YZID"].ToString().Trim();
                TZYZXX yzxx = XLBJDUtils.GetYZXXByYZID(sYZID);
                string sYZMC = yzxx.XLXSTZYZ_YZMC.Trim();
                if (!dic.ContainsKey(sYZID))
                    dic.Add(sYZID, sYZMC);
            }
            return dic;
        }

        private string ConvertCodeToName(string sFormula)
        {
            if (string.IsNullOrEmpty(sFormula))
                return sFormula;
            string sResult = sFormula.Replace("JGBJJ", "价格表基价");
            Dictionary<string, string> dicYZ = GetYZIDNameMap();
            foreach (KeyValuePair<string, string> kvp in dicYZ)
            {
                sResult = sResult.Replace(kvp.Key, kvp.Value);
            }
            return sResult;
        }

        private string ConvertNameToCode(string sFormula)
        {
            if (string.IsNullOrEmpty(sFormula))
                return sFormula;
            string sResult = sFormula.Replace("价格表基价", "JGBJJ");
            Dictionary<string, string> dicYZ = GetYZIDNameMap();
            //按名称长度降序替换，避免短名称被长名称包含时误替换
            List<KeyValuePair<string, string>> lstYZ = new List<KeyValuePair<string, string>>(dicYZ);
            lstYZ.Sort(delegate(KeyValuePair<string, string> a, KeyValuePair<string, string> b)
            {
                return b.Value.Length.CompareTo(a.Value.Length);
            });
            foreach (KeyValuePair<string, string> kvp in lstYZ)
            {
                sResult = sResult.Replace(kvp.Value, kvp.Key);
            }
            return sResult;
        }

        //允许加入因子，返回true 因子顺序不符合规格，返回false
        private bool CanYZIDSave(TDatabase dberp, TSQL sql, string sJGBID, string sYZID)
        {
            if (IsQYGS(sJGBID))
                return true;
            Dictionary<string, string> dicXLXSTZYZ = new Dictionary<string, string>();
            dicXLXSTZYZ.Clear();
            DataSet ds = new DataSet();

            sql.Clear();
            sql.Add(" select XLXSJGBYZ_YZID,XLXSTZYZ_JJFS from XLXSJGBYZ ");
            sql.Add(" left join XLXSTZYZ on XLXSTZYZ_YZID = XLXSJGBYZ_YZID ");
            sql.Add(" where XLXSJGBYZ_JGBID =:pJGBID ");
            if (!sYZID.Equals(""))
            {
                sql.Add(" and XLXSJGBYZ_YZID <> :pYZID ");
                sql.ParamByName("pYZID").Value = sYZID;
            }
            sql.Add(" and isnull(XLXSTZYZ_BCYTJ,'N') <> 'Y' ");
            sql.Add(" order by XLXSTZYZ_XSXH ");
            sql.ParamByName("pJGBID").Value = sJGBID;
            ds = dberp.OpenDataSet(sql);
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                dicXLXSTZYZ.Add(ds.Tables[0].Rows[i]["XLXSJGBYZ_YZID"].ToString().Trim(), ds.Tables[0].Rows[i]["XLXSTZYZ_JJFS"].ToString().Trim());
            }
            List<string> lst = new List<string>();
            lst.Clear();
            //如果是扣点/加点，则加入 1  如果是加价则加入 0，最终形成：空或者01或者10或者1或者0，不能形成101形式或者010形式或者1010等大于2个数据的形式
            foreach (KeyValuePair<string, string> kvp in dicXLXSTZYZ)
            {
                if (kvp.Value.Equals("JJ"))
                {
                    if (lst.Count == 0)
                    {
                        lst.Add("0");
                    }
                    else if (lst[lst.Count - 1] == "1")
                    {
                        lst.Add("0");
                    }
                    else if (lst[lst.Count - 1] == "0")
                    {
                        //不处理
                    }
                }
                else 
                {
                    //JD  KD MX  
                    if (lst.Count == 0)
                    {
                        lst.Add("1");
                    }
                    else if (lst[lst.Count - 1] == "1")
                    {
                        //不处理
                    }
                    else if (lst[lst.Count - 1] == "0")
                    {
                        lst.Add("1");
                    }
                }
            }

            if (lst.Count >= 3)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        private bool IsQYGS(string sJGBID)
        {
            if (CMISproDataBase.ExistsRecord("DBERP", string.Format("select 1 from XLXSJGB where XLXSJGB_JGBID='{0}' and isnull(XLXSJGB_JSGS,' ') <> ' ' ", sJGBID)))
                return true;
            return false;
        }

        //存在上点除、下点乘的加价方式
        private bool HasSXJJFS(string sJGBID)
        {
            List<JGBYZXX> jgbYZ = XLBJDUtils.GetJGBYZXXByJGBID(sJGBID);
            if (jgbYZ.Count > 0)
            {
                foreach (JGBYZXX sYZ in jgbYZ)
                {
                    TZYZXX yzxx = XLBJDUtils.GetYZXXByYZID(sYZ.XLXSJGBYZ_YZID);
                    if (yzxx.XLXSTZYZ_JJFS.Equals("SX"))
                        return true;
                }
            }
            return false;
        }
        //获取当前价格表所使用的因子ID、计算顺序、调价类型、调价因子ID、加价方式
        public static List<XLXSJGBYZXX> GetJGBYZXX(string sJGBID, out Dictionary<string, string> YZJJFS)
        {
            YZJJFS = new Dictionary<string, string>();
            List<XLXSJGBYZXX> YZXX_List = new List<XLXSJGBYZXX>();
            List<JGBYZXX> jgbYZ = XLBJDUtils.GetJGBYZXXByJGBID(sJGBID);
            if (jgbYZ.Count > 0)
            {
                foreach (JGBYZXX sYZ in jgbYZ)
                {
                    TZYZXX yzxx = XLBJDUtils.GetYZXXByYZID(sYZ.XLXSJGBYZ_YZID);
                    XLXSJGBYZXX jgbYZXX = new XLXSJGBYZXX();
                    jgbYZXX.YZID = yzxx.XLXSTZYZ_YZID;
                    jgbYZXX.JSXH = CMISproConvert.StrToFloat(yzxx.XLXSTZYZ_XSXH);
                    jgbYZXX.TJLX = yzxx.XLXSTZYZ_TJLX;
                    jgbYZXX.TJYZID = yzxx.XLXSTZYZ_TJYZID;
                    jgbYZXX.JJFS = yzxx.XLXSTZYZ_JJFS;
                    jgbYZXX.YZZGS = yzxx.XLXSTZYZ_YZID;
                    YZXX_List.Add(jgbYZXX);
                    YZJJFS[jgbYZXX.YZID] = jgbYZXX.JJFS;
                }

            }
            YZXX_List.Sort(new XLXSJGBYZXXComparer());
            return YZXX_List;

        }

        public static string GetJSGS(string sJGBID)
        {
            Dictionary<string, string> YZJJFS = new Dictionary<string, string>();
            List<XLXSJGBYZXX> JGBYZXX_List = GetJGBYZXX(sJGBID, out YZJJFS);
            string formula = "JGBJJ";
            //按分组相加
            Dictionary<string, XLXSJGBYZXX> groupedSums = new Dictionary<string, XLXSJGBYZXX>();
            foreach (XLXSJGBYZXX item in JGBYZXX_List)
            {
                if (groupedSums.ContainsKey(item.TJYZID))
                {
                    groupedSums[item.TJYZID].YZZGS = "(" + groupedSums[item.TJYZID].YZZGS + "+" + item.YZZGS + ")";
                }
                else
                {
                    groupedSums[item.TJYZID] = item;
                }
            }
            //生成计算公式
            foreach (XLXSJGBYZXX item in groupedSums.Values)
            {
                formula = GetJSGSbyJJFS(formula, item.YZZGS, item.JJFS);
            }

            return formula;
        }

        public static string GetJSGSbyJJFS(string sformula, string sYZZGS, string sJJFS)
        {
            switch (sJJFS)
            {

                case "JD": return sformula + "*(1+" + sYZZGS + "/100)";

                case "KD": return sformula + "/(1-" + sYZZGS + "/100)";

                case "DD": return sformula + "/(1+" + sYZZGS + "/100)";

                case "MD": return sformula + "*(1-" + sYZZGS + "/100)";

                case "JJ": return "(" + sformula + "+" + sYZZGS + ")";

                case "MX": return sformula + "*" + sYZZGS;

                case "DX": return sformula + "/(" + sYZZGS + ")";

                default: return sformula;
            }
        }

        #endregion

        #region 控件事件

        protected void ContentGrid_RowDoubleClick(object sender, GThinking.N_CONTROL.RowDoubleClickEventArgs e)
        {
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL sql = new TSQL(dberp);
            string sJGBID   = PageParam.GetRTrimString("JGBID");
            string sYZID    = ContentGrid.DataKeys[ContentGrid.SelectedIndex]["YZID"].ToString().Trim();
            bool bChecked = false;

            List<JGBYZXX> jgbyz_List = XLBJDUtils.GetJGBYZXXByJGBID(sJGBID);
            foreach (JGBYZXX jgbyz in jgbyz_List)
            {
                if (jgbyz.XLXSJGBYZ_YZID.Equals(sYZID))
                {
                    bChecked = true;
                    break;
                }
            }
            if (bChecked)
            {

                if (!CanYZIDSave(dberp, sql, sJGBID, sYZID))
                {
                    ShowMessage("当前选择因子不满足“加价因子必须全部在加点/扣点因子之前或者之后”规则，不允许去除！请至“100860004|线缆销售价格表因子”模块调整因子顺序或者重新选择因子！");
                    return;
                }
                dberp.ExecSQL(string.Format("delete from XLXSJGBYZ where XLXSJGBYZ_JGBID='{0}' and XLXSJGBYZ_YZID='{1}'", sJGBID, sYZID));
            }
            else
            {
                if (IsQYGS(sJGBID) && CMISproDataBase.ExistsRecord("DBERP", string.Format("select 1 from XLXSTZYZ  where XLXSTZYZ_MXBH='JZJ' and XLXSTZYZ_YZID='{0}' and XLXSTZYZ_JJFS = 'SX'  ", sYZID)))
                {
                    ShowMessage("当前价格表已启用公式，不允许选择调价方式为“上点除、下点乘”的因子！");
                    return;
                }

                try
                {
                    dberp.BeginTrans();
                    sql.Clear();
                    sql.Add("insert into XLXSJGBYZ(XLXSJGBYZ_JGBID,XLXSJGBYZ_YZID,XLXSJGBYZ_BZ,XLXSJGBYZ_WHR,XLXSJGBYZ_WHRID,XLXSJGBYZ_WHSJ)");
                    sql.Add(" values(:XLXSJGBYZ_JGBID,:XLXSJGBYZ_YZID,:XLXSJGBYZ_BZ,:XLXSJGBYZ_WHR,:XLXSJGBYZ_WHRID,:XLXSJGBYZ_WHSJ)");
                    sql.ParamByName("XLXSJGBYZ_JGBID").Value = sJGBID;
                    sql.ParamByName("XLXSJGBYZ_YZID").Value = sYZID;
                    sql.ParamByName("XLXSJGBYZ_BZ").Value = "";
                    sql.ParamByName("XLXSJGBYZ_WHR").Value = tSession.UserName;
                    sql.ParamByName("XLXSJGBYZ_WHRID").Value = tSession.UserId;
                    sql.ParamByName("XLXSJGBYZ_WHSJ").Value = DateTime.Now;
                    dberp.ExecSQL(sql);

                    if (!CanYZIDSave(dberp, sql, sJGBID, ""))
                    {
                        throw new Exception();
                    }
                    dberp.CommitTrans();
                }
                catch
                {
                    ShowMessage("当前选择因子不满足“加价因子必须全部在加点/扣点因子之前或者之后”规则，不允许添加！请至“100860004|线缆销售价格表因子”模块调整因子顺序或者重新选择因子！");
                    dberp.RollbackTrans();
                }


            }
            CacheNotify.TableIsUpdated("DBERP", "XLXSJGBYZ");
            if (IsQYGS(sJGBID))
            {
                btnQYGS_Click(null, null);
            }
            else
            {
                moduleGV_PageIndexChanging(null, null);
                FormAreaUpdate();
            }
        }
        protected void btnQYGS_Click(object sender, EventArgs e)
        {
            string sJGBID = PageParam.GetRTrimString("JGBID");
            if (HasSXJJFS(sJGBID))
            {
                ShowMessage("当前价格表使用的调价因子存在“上点除，下点乘”调价方式，不允许启用公式！");
                return;
            }
            string sJSGS = GetJSGS(sJGBID);
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add("update XLXSJGB set XLXSJGB_JSGS=:pJSGS where XLXSJGB_JGBID=:pJGBID");
            SQL.ParamByName("pJSGS").Value = sJSGS;
            SQL.ParamByName("pJGBID").Value = sJGBID;
            dberp.ExecSQL(SQL);
            txtJSGS.Text = ConvertCodeToName(sJSGS);
            moduleGV_PageIndexChanging(null, null);
            FormAreaUpdate();
        }

        protected void btnGXGS_Click(object sender, EventArgs e)
        {
            string sJGBID = PageParam.GetRTrimString("JGBID");
            string sCodeFormula = ConvertNameToCode(txtJSGS.Text.Trim());
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            SQL.Clear();
            SQL.Add("update XLXSJGB set XLXSJGB_JSGS=:pJSGS where XLXSJGB_JGBID=:pJGBID");
            SQL.ParamByName("pJSGS").Value = sCodeFormula;
            SQL.ParamByName("pJGBID").Value = sJGBID;
            dberp.ExecSQL(SQL);
            txtJSGS.Text = ConvertCodeToName(sCodeFormula);
            ShowMessage("公式已更新！");
        }

        protected void btnQKGS_Click(object sender, EventArgs e)
        {
            string sJGBID = PageParam.GetRTrimString("JGBID");
            if (!IsQYGS(sJGBID))
            {
                ShowMessage("未启用公式！");
                return;
            }
            TDatabase dberp = TContextDatabases.GetDatabase("DBERP");
            TSQL SQL = new TSQL(dberp);
            try
            {
                dberp.BeginTrans();
                SQL.Clear();
                SQL.Add("update XLXSJGB set XLXSJGB_JSGS=' ' where XLXSJGB_JGBID=:pJGBID");
                SQL.ParamByName("pJGBID").Value = sJGBID;
                dberp.ExecSQL(SQL);
                if (!CanYZIDSave(dberp, SQL, sJGBID, ""))
                {
                    throw new Exception();
                }
                dberp.CommitTrans();
                txtJSGS.Text = "";
            }
            catch
            {
                ShowMessage("当前选择因子不满足“加价因子必须全部在加点/扣点因子之前或者之后”规则，不允许清空公式！请至“100860004|线缆销售价格表调价因子”模块调整因子顺序或者重新选择因子！");
                dberp.RollbackTrans();
            }

            moduleGV_PageIndexChanging(null, null);
            FormAreaUpdate();
        }

        #endregion
    }
    public class XLXSJGBYZXX
    {
        private string _YZID;
        public string YZID
        {
            get
            {
                return _YZID;
            }
            set
            {
                _YZID = value; ;
            }

        }

        private double _JSXH;
        public double JSXH
        {
            get
            {
                return _JSXH;
            }
            set
            {
                _JSXH = value; ;
            }
        }

        private string _TJLX;
        public string TJLX
        {
            get
            {
                return _TJLX;
            }
            set
            {
                _TJLX = value; ;
            }
        }

        private string _TJYZID;
        public string TJYZID
        {
            get
            {
                return _TJYZID;
            }
            set
            {
                _TJYZID = value; ;
            }
        }

        private string _JJFS;
        public string JJFS
        {
            get
            {
                return _JJFS;
            }
            set
            {
                _JJFS = value; ;
            }
        }

        private string _YZZGS;
        public string YZZGS
        {
            get
            {
                return _YZZGS;
            }
            set
            {
                _YZZGS = value; ;
            }
        }
    }

    public class XLXSJGBYZXXComparer : IComparer<XLXSJGBYZXX>
    {
        public int Compare(XLXSJGBYZXX x, XLXSJGBYZXX y)
        {
            if (x.JSXH == y.JSXH)
                return x.YZID.CompareTo(y.YZID);
            return x.JSXH.CompareTo(y.JSXH);

        }
    }
}