using System;
using System.Collections.Generic;
using System.Collections;
using System.Data;
using System.Data.OleDb;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Diagnostics;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Net;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Runtime.Serialization.Json;
using Newtonsoft.Json;
namespace DeiNiu.Utils
{

  //  public enum op_flag { add = 1, update, delete, getObj, queryAll, queryExample,queryActived,getPk, getCount}; 
//    public enum ProjectStatus { 新增未提交, 新增待预审, 新增预审通过, 新增预审未通过, 新增审核通过, 新增审核未通过, 新增考核通过, 新增考核未通过,删减未提交,删减待预审,删减预审通过,删减预审未通过,删减审核通过,删减审核未通过,删减考核通过,删减考核未通过,项目完成 };
    public enum FileType {Project,ProjectDetail,半年度总结,年度总结,半年度计划,年度计划 };
    public struct ProjectDetailStatus
    {
        public static string 审核未通过
        {
            get
            {
                return "审核未通过";
            }
        }

        public static string 考核通过
        {
            get
            {
                return "考核通过";
            }
        }
        public static string 考核未通过
        {
            get
            {
                return "考核未通过";
            }
        }

        public static string 月度未提交
        {
            get
            {
                return "月度未提交";
            }
        }

        public static string 月度已提交
        {
            get
            {
                return "月度已提交";
            }
        }
        public static string 待预审
        {
            get
            {
                return "待预审";
            }
        }
        public static string 预审通过
        {
            get
            {
                return "预审通过";
            }
        }
        public static string 预审未通过
        {
            get
            {
                return "预审未通过";
            }
        }
        public static string 审核通过
        {
            get
            {
                return "审核通过";
            }
        }
    }
    public struct ApproveRoles
    {
        public static string YuShen
        {
            get
            {
                return "项目预审";
            }
        }
        public static string ShenHe
        {
            get
            {
                return "项目审核";
            }
        }
        public static string KaoHe
        {
            get
            {
                return "项目考核";
            }
        }
        public static string 项目维护
        {
            get
            {
                return "项目维护";
            }
        }
    }
    public struct ProjectStatus
    {

        public static string 项目已分配
        {
            get
            {
                return "项目已分配";
            }
        }
        public static string 项目未分配
        {
            get
            {
                return "项目未分配";
            }
        }

        public static string 新增未提交
        {
            get
            {
                return "新增未提交";
            }
        }


        public static string 新增已提交
        {
            get
            {
                return "新增已提交";
            }
        }

         public static string 新增考核通过
        {
            get
            {
                return "新增考核通过";
            }
        }
        public static string 项目冻结
        {
            get
            {
                return "项目冻结";
            }
        }
        public static string 项目解冻
        {
            get
            {
                return "项目解冻";
            }
        }
         public static string 新增审核通过
        {
            get
            {
                return "新增审核通过";
            }
        }
            public static string 新增审核未通过
        {
            get
            {
                return "新增审核未通过";
            }
        }
         public static string 新增预审未通过
        {
            get
            {
                return "新增预审未通过";
            }
        }
         public static string 新增预审通过
        {
            get
            {
                return "新增预审通过";
            }
        }
        

          public static string 删减审核未通过
        {
            get
            {
                return "删减审核未通过";
            }
        }

         public static string 删减审核通过
        {
            get
            {
                return "删减审核通过";
            }
        }
         public static string 删减预审未通过
        {
            get
            {
                return "删减预审未通过";
            }
        }
            public static string 删减预审通过
        {
            get
            {
                return "删减预审通过";
            }
        }
       
         public static string 删减未提交
        {
            get
            {
                return "删减未提交";
            }
        }
        public static string 删减已提交
        {
            get
            {
                return "删减已提交";
            }
        }
         public static string 新增考核未通过
        {
            get
            {
                return "新增考核未通过";
            }
        }
            public static string 项目完成
        {
            get
            {
                return "项目完成";
            }
        }
        public static string 项目未完成
        {
            get
            {
                return "项目未完成";
            }
        }
         public static string 删减考核未通过
        {
            get
            {
                return "删减考核未通过";
            }
        }
         public static string 删减考核通过
        {
            get
            {
                return "删减考核通过";
            }
        }  
    }

 　  public struct appScope
    {
        /// <summary>
        /// used for  storing logic object in session
        /// when page changes in server side, logic object in session
        /// will be replaced by new one.
        /// </summary>
        public static string PagelevelObj
        {
            get
            {
                return "PageLevelObj";
            }
        }

      
    }

    public class MyTracer
    {
        private static TraceSwitch appSwitch = new TraceSwitch("TraceSwitch", "Switch in config file");

        private static string render(object clz, string msg)
        {
            //time
            StringBuilder sb = new StringBuilder();
            DateTime dt = DateTime.Now;
            sb.Append(dt.ToLongDateString()).Append(" ").Append(dt.ToLongTimeString()).Append(" - ");
            
            
            StackTrace stackTrace = new StackTrace();
            StackFrame stackFrame = stackTrace.GetFrame(2);

            //class name
            sb.Append(clz.GetType().FullName).Append(" [");
            
            //method name
            MethodBase methodBase = stackFrame.GetMethod();

            sb.Append(methodBase.Name).Append("] ");

            //the msg
            sb.Append(msg);

            return sb.ToString();
            
        }
        public static void Error(object clz, string msg)
        {
            Trace.WriteLineIf(appSwitch.TraceError, render(clz, "[ERROR] " + msg));
        }
        public static void Warning(object clz, string msg)
        {
            Trace.WriteLineIf(appSwitch.TraceWarning, render(clz, "[WARNING] " + msg));
        }
        public static void Info(object clz, string msg)
        {
            Trace.WriteLineIf(appSwitch.TraceInfo, render(clz, "[INFO] " + msg));
        }
        public static void Verbose(object clz, string msg)
        {
            Trace.WriteLineIf(appSwitch.TraceVerbose, render(clz, "[VERBOSE] " + msg));
        }
    }

    public class Util
    {
        public static string Encrypt(string password)//加密函数
        {
            /*
            Byte[] clearBytes = new UnicodeEncoding().GetBytes(password);
            Byte[] hashedBytes = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(clearBytes);
            return BitConverter.ToString(hashedBytes);
            */
            return MD5(password);
        }

        //http://events.jianshu.io/p/41b07b52fc33
        public static String MD5(String str)

        {

            byte[] result = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(Encoding.UTF8.GetBytes(str));

            StringBuilder output = new StringBuilder(16);

            for (int i = 0; i < result.Length; i++)

            {

                // convert from hexa-decimal to character?

                output.Append((result[i]).ToString("x2", System.Globalization.CultureInfo.InvariantCulture));

            }

            return output.ToString();

        }

   
  
 
       public static void GetCheckedNode(TreeNodeCollection tnc, ArrayList checkedvalues)
        {
            foreach (TreeNode node in tnc)
            {
                if (node.Checked)
                {
                    checkedvalues.Add(node.Value);

                }
                GetCheckedNode(node.ChildNodes, checkedvalues);
            }
        }
        public static void GetCheckedNode(TreeNodeCollection tnc, ArrayList checkedvalues,ArrayList checkedText)
        {
            foreach (TreeNode node in tnc)
            {
                if (node.Checked)
                {
                    checkedvalues.Add(node.Value);
                    checkedText.Add(node.Text);

                }
                GetCheckedNode(node.ChildNodes, checkedvalues);
            }
        }

      public static  void SetCheckedNode(TreeNodeCollection tnc, ArrayList setcheckedvalues)
        {
            foreach (TreeNode node in tnc)
            {
                node.Checked = setcheckedvalues.Contains(Convert.ToInt32(node.Value));

                SetCheckedNode(node.ChildNodes, setcheckedvalues);
            }
        }

        /// <summary>
        /// 组合in sql,return like " 1,2,3"
        /// </summary>
        /// <param name="al"></param>
        /// <returns></returns>
        public static string buildWhereIntIn(ArrayList al)
        {
            string whereString = string.Empty;

            for (int i = 0; i < al.Count; i++)
            {
                whereString += "'"+ al[i] + "',";
            }
            if (whereString.EndsWith(","))
            {
                whereString = whereString.Substring(0, whereString.Length - 1);
            }
            return whereString;
        }

        public static DataSet Excel2DataSet(string filepath)
        {
            DataSet ds = new DataSet();
            ArrayList SheeNames = ExcelSheetName(filepath);
            for(int i=0;i<SheeNames.Count;i++)
            {
                DataTable dt = (ExcelDataSource(filepath, SheeNames[i].ToString())).Tables[0].Copy();
                dt.TableName = SheeNames[i].ToString();
                dt.TableName = dt.TableName.Substring(0, dt.TableName.IndexOf("$"));
                ds.Tables.Add(dt); 
            }
            return ds;
        }
        //该方法实现从Excel中导出数据到DataSet中，其中filepath为Excel文件的绝对路径， sheetname为excel文件中的表名
        public static DataSet ExcelDataSource(string filepath, string sheetname)
        {
            string strConn;
            strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + filepath + ";Extended Properties=Excel 8.0;";
            OleDbConnection conn = new OleDbConnection(strConn);
            OleDbDataAdapter oada = new OleDbDataAdapter("select * from [" + sheetname + "]", strConn);
            DataSet ds = new DataSet();
            oada.Fill(ds);
            conn.Close();
            return ds;
        }

        //获得Excel中的所有sheetname。
        public static ArrayList ExcelSheetName(string filepath)
        {
            ArrayList al = new ArrayList();
            string strConn;
            strConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + filepath + ";Extended Properties=Excel 8.0;";
            OleDbConnection conn = new OleDbConnection(strConn);
            conn.Open();
            DataTable sheetNames = conn.GetOleDbSchemaTable
            (System.Data.OleDb.OleDbSchemaGuid.Tables, new object[] { null, null, null, "TABLE" });
            conn.Close();
            foreach (DataRow dr in sheetNames.Rows)
            {
                al.Add(dr[2]);
            }
            return al;
        }

        public　static　DataView　GetTopDataViewRows(DataView　dv,　int　n)
　  　　　　　{
　 　　　　　　　　　DataTable　dt　=　dv.Table.Clone();
　 　
　 　　　　　　　　　for　(int　i　=　0;　i　<　n　-　1;　i++)
　 　　　　　　　　　{
　 　　　　　　　　　　　　　if　(i　>=　dv.Count)
　 　　　　　　　　　　　　　{
　 　　　　　　　　　　　　　　　　　break;
 　　　　　　　　　　　　　}
 　　　　　　　　　　　　　dt.ImportRow(dv[i].Row);
 　　　　　　　　　 }
 　　　　　　　　return　new　DataView(dt,　dv.RowFilter,　dv.Sort,　 dv.RowStateFilter);
 　　　　　}


        /// <summary>
        /// 读取配置文件某项的值
        /// </summary>
        /// <param name="key">appSettings的key</param>
        /// <returns>appSettings的Value</returns>
        //public static string GetConfig(string key)
        //{
            //string _value = string.Empty;
            //System.Configuration.ConfigurationManager  config =  System.Configuration.ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            //if (config.AppSettings.Settings[key] != null)
            //{
            //    _value = config.AppSettings.Settings[key].Value;
            //}
            //return _value;
        //}
        private static char[] constant =   
      {   
        '0','1','2','3','4','5','6','7','8','9',  
        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',   
        'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'   
      };
        public static string GenerateRandomNumber(int Length)
        {
            System.Text.StringBuilder newRandom = new System.Text.StringBuilder(62);
            Random rd = new Random();
            for (int i = 0; i < Length; i++)
            {
                newRandom.Append(constant[rd.Next(62)]);
            }
            return newRandom.ToString().ToUpper();
        }

        //条形码转换
        public static string getCode128(string codeIn)
        {
            //string str ="";
            string result;
            int checksum = 104;
            for (int i = 0; i < codeIn.Length; i++)
            {
                if (codeIn[i] >= 32)
                {
                    checksum += (codeIn[i] - 32) * (i + 1);
                }
                else
                {
                    checksum += (codeIn[i] + 64) * (i + 1);
                }
            }
            checksum = checksum % 103;
            if (checksum < 95)
            {
                checksum += 32;
            }
            else
            {
                checksum += 100;
            }
            result = Convert.ToChar(204) + codeIn +
            Convert.ToChar(checksum) + Convert.ToChar(206);
            return result;
        }

        public static string getPrefix(enumCreateOrderType orderType)
        {
            string prefix = "UN";
            switch (orderType)
            {
                case enumCreateOrderType.repOrderIn:
                    prefix = "RPI";
                    break;
                case enumCreateOrderType.repOrderOut:
                    prefix = WmsConstants.ORDER_PRI_RPO;// "RPO";
                    break;
                case enumCreateOrderType.pickOrder:
                    prefix = WmsConstants.ORDER_PRI_PICK;//"PICK";
                    break;
                case enumCreateOrderType.waveOrder:
                    prefix = WmsConstants.ORDER_PRI_WAVE;//"WAVE";
                    break;
                case enumCreateOrderType.transOrder:
                    prefix = WmsConstants.ORDER_PRI_TRAN;//"TRAN";
                    break;
                case enumCreateOrderType.seedsPickOrder:
                    prefix = WmsConstants.ORDER_PRI_SEEDS;//"SEED";
                    break;

                case enumCreateOrderType.pandianOrder:
                    prefix = WmsConstants.ORDER_PRI_PANDIAN;//"PAN";
                    break;

                case enumCreateOrderType.preInOrder:
                    prefix = WmsConstants.ORDER_PRI_INORDER;//"PREIN";
                    break;
                case enumCreateOrderType.pickJobNo:
                    prefix = WmsConstants.ORDER_PRI_WAVEJOB;//"PREIN";
                    break;
                case enumCreateOrderType.dpsOrder:
                    prefix = WmsConstants.ORDER_DPS_WAVE;//"PREIN";
                    break;
                case enumCreateOrderType.obsolete:
                    prefix = WmsConstants.ORDER_PRI_OBSOLETE;//"PREIN";
                    break;
                case enumCreateOrderType.transferOutside:
                    prefix = WmsConstants.ORDER_PRI_TRANSFER_OUTSIDE;//"PREIN";
                    break;
                case enumCreateOrderType.transferInternal:
                    prefix = WmsConstants.ORDER_PRI_TRANSFER_INSIDE;//"PREIN";
                    break;
                case enumCreateOrderType.returnVender:
                    prefix = WmsConstants.ORDER_PRI_RETURN_VENDER;//"PREIN";
                    break;
                case enumCreateOrderType.pickOutInvoice:
                    prefix = WmsConstants.ORDER_PRI_PICK_OUT_INVOICE;//"PREIN";
                    break;


            }
            return prefix;
        }

        public static string getOrderNo(enumCreateOrderType orderType, int seq )
        { 

            string prefix = getPrefix(orderType);


            string orderno = string.Format("{0}{1:D2}{2:D2}{3:D2}{4:D6}", prefix, DateTime.Now.Year - 2000,
                DateTime.Now.Month, DateTime.Now.Day, seq); 
           // LogHelper.debug("Utils", string.Format( "create order no ,seq is {0}, orderno is {1}",   seq,orderno));
            return orderno;
        }
        public static enumStockRecordType getStockRecordType(int outStoretype)
        {
            enumOutStoreType ost = (enumOutStoreType)outStoretype;

            switch (ost)
            {
                case enumOutStoreType.报废出库:
                    return enumStockRecordType.报废出库;
                case enumOutStoreType.返厂出库:
                    return enumStockRecordType.退供应商出库;
                case enumOutStoreType.销售出库:
                    return enumStockRecordType.销售出库;
                case enumOutStoreType.补货出库:
                    return enumStockRecordType.补零出库;
                case enumOutStoreType.配货汇总拣货出库:
                    return enumStockRecordType.集货出库;
                default:
                    return enumStockRecordType.销售出库;
            }
             
        }

        public static string getShortDateString(string date)
        {
            //  DateTimeFormatInfo dtFormat = new System.Globalization.DateTimeFormatInfo() ;

            //  dtFormat.ShortDatePattern = "yyyy-MM-dd";
            // return Convert.ToDateTime(date, dtFormat);
            DateTime dt;
            try
            {
                dt = Convert.ToDateTime(date);
                return string.Format("{0}-{1:d2}-{2:d2}", dt.Year, dt.Month, dt.Day);
            }
            catch  { }

            try
            {
                dt = DateTime.ParseExact(date, "yyyyMMdd", System.Globalization.CultureInfo.CurrentCulture);
                return string.Format("{0}-{1:d2}-{2:d2}", dt.Year, dt.Month, dt.Day);
            }
            catch { }

            return null;

        }


        public static enumOutStoreType getOutStoreTypeByOrderType(int orderType)
        {
            enumOrderType ost = (enumOrderType)orderType;

            switch (ost)
            {
                case enumOrderType.报废申请:
                    return enumOutStoreType.报废出库;
                case enumOrderType.仓间调拨:
                    return enumOutStoreType.调拨出库;
                case enumOrderType.库区转移:
                    return enumOutStoreType.移库出库;
                case enumOrderType.退供应商:
                    return enumOutStoreType.返厂出库;
                default:
                     return enumOutStoreType.报废出库;;
            }
             
        }
        public static EnumFlowTaskType getTaskType(int recordType)
        {
            enumStockRecordType type = (enumStockRecordType)recordType;

            switch (type)
            {
                case enumStockRecordType.报废出库:
                    return EnumFlowTaskType.报废下架;
                case enumStockRecordType.补零出库:
                    return EnumFlowTaskType.储存区补货下架;
                case enumStockRecordType.补零入库:
                    return EnumFlowTaskType.拣货区补货上架;
                case enumStockRecordType.销售出库:
                    return EnumFlowTaskType.出库拣货下架;
                case enumStockRecordType.普通入库:
                    return EnumFlowTaskType.入库上架;
                case enumStockRecordType.移库上架:
                    return EnumFlowTaskType.移库上架;
                case enumStockRecordType.移库下架:
                    return EnumFlowTaskType.移库下架;
                case enumStockRecordType.退供应商出库:
                  return EnumFlowTaskType.移库下架;
                case enumStockRecordType.退供应商入库:
                  return EnumFlowTaskType.移库上架;
                case enumStockRecordType.直通越仓:
                    return EnumFlowTaskType.直通集货;

                default:
                     return   EnumFlowTaskType.出库拣货下架; 
            }
             
        }
        

        public static enumWhType getTargetWhType(enumOrderType orderType,enumWhType fromWh= enumWhType.合格库)
        {
            switch (orderType)
            {
                case enumOrderType.报废申请: 
                     return enumWhType.报废库;
                    
                case enumOrderType.库区转移: 
                      return fromWh; 
                   
                case enumOrderType.退供应商:
                    return enumWhType.返厂库;
                default: return enumWhType.不合格库;
            }
        }
        public static long getTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalMilliseconds);
        }

        public static string getPartLightKey(int color, int labelId, int address,int part)
        {
            return string.Format("{0}-{1}-{2}", color, labelId, address);
        }


        public static string getLightKey(int color,int labelId, int address)
        {
            return string.Format("{0}-{1}-{2}", color, labelId, address);
        }

        public static string getBoxId( int type, int color,int id)
        {
            return string.Format("H-{0}-{1}-{2}",type, color,  id);
        }
        public static int getBoxColor(string boxId)
        {
             string[] s=  boxId.Split('-');
            return Convert.ToInt16(s[2].ToString());
        }
        public static int getBoxId(string boxId)
        {
            string[] s = boxId.Split('-');
            return Convert.ToInt16(s[3].ToString());
        }

        public static Dictionary<int,string> convertEnumToDic(Type enumType){

            Dictionary<int, string> dic = new Dictionary<int, string>();
            foreach (int myCode in Enum. GetValues(enumType))
            {
                string strName = Enum.GetName(enumType, myCode);//获取名称
                string strVaule = myCode.ToString();//获取值
                dic[myCode] = strName;
               
            }

            return dic;
    }
 

        public static DateTime pareseDateString(string dateStr){
            /*
             string[] invailidChars = { ".","-","/"};

            foreach (string s in invailidChars)
            {
                if (WmsConstants.GOODS_VALID_DATE_FORMAT.IndexOf(s) == -1)
                {
                    dateStr = dateStr.Replace(s, "x");
                   
                }
            }
            string year = dateStr.Split('x')[0];
            string month = dateStr.Split('x')[1];
            string day = dateStr.Split('x')[2];

            month = month.Length == 1 ? "0" + month : month;
            day = day.Length == 1 ? "0" + day : day;

            dateStr = year + month + day;
            */


            try
            {
                return DateTime.ParseExact(dateStr, WmsConstants.GOODS_VALID_DATE_FORMAT, System.Globalization.CultureInfo.CurrentCulture);
            }
            catch (Exception)
            {

                return DateTime.ParseExact(dateStr,"yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture);
            }


          //  return DateTime.ParseExact(dateStr, WmsConstants.GOODS_VALID_DATE_FORMAT, System.Globalization.CultureInfo.CurrentCulture);  

        }


        /// <summary>
        /// 获取本机所有ip地址
        /// </summary>
        /// <param name="netType">"InterNetwork":ipv4地址，"InterNetworkV6":ipv6地址</param>
        /// <returns>ip地址集合</returns>
        public static List<string> GetLocalIpAddress(string netType)
        {
            string hostName = Dns.GetHostName();                    //获取主机名称
            IPAddress[] addresses = Dns.GetHostAddresses(hostName); //解析主机IP地址

            List<string> IPList = new List<string>();
            if (netType == string.Empty)
            {
                for (int i = 0; i < addresses.Length; i++)
                {
                    IPList.Add(addresses[i].ToString());
                }
            }
            else
            {
                //AddressFamily.InterNetwork表示此IP为IPv4,
                //AddressFamily.InterNetworkV6表示此地址为IPv6类型
                for (int i = 0; i < addresses.Length; i++)
                {
                    if (addresses[i].AddressFamily.ToString() == netType)
                    {
                        IPList.Add(addresses[i].ToString());
                    }
                }
            }
            return IPList;
        }
        /// <summary>
        /// 人民币大写转换
        /// </summary>
        /// <param name="number">数字</param>
        /// <returns>返回人民币大写,如：壹元整</returns>
        public static string convertToChinese(decimal number)
        {
            var s = number.ToString("#L#E#D#C#K#E#D#C#J#E#D#C#I#E#D#C#H#E#D#C#G#E#D#C#F#E#D#C#.0B0A");
            var d = Regex.Replace(s, @"((?<=-|^)[^1-9]*)|((?'z'0)[0A-E]*((?=[1-9])|(?'-z'(?=[F-L\.]|$))))|((?'b'[F-L])(?'z'0)[0A-L]*((?=[1-9])|(?'-z'(?=[\.]|$))))", "${b}${z}");
            var r = Regex.Replace(d, ".", m => "负元空零壹贰叁肆伍陆柒捌玖空空空空空空空分角拾佰仟万亿兆京垓秭穰"[m.Value[0] - '-'].ToString());
            return r;
        }
        public static string getJson(Object obj)
        {
            try
            { 

               return JsonConvert.SerializeObject(obj);
                /*
                   DataContractJsonSerializer jsonSerializer
                               = new DataContractJsonSerializer(typeof(Object));
                var stream = new MemoryStream();
                jsonSerializer.WriteObject(stream, obj);

                byte[] dataBytes = new byte[stream.Length];

                stream.Position = 0;

                stream.Read(dataBytes, 0, (int)stream.Length);

                string dataString = Encoding.UTF8.GetString(dataBytes);

                return dataString;
                */
            }
            catch (Exception e) {

               
                LogHelper.debug("Utls", e.Message); 
                
                return e.Message;
            }



        }
    }
}