using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using WCS_Client.Extensions;
using WCS_Client.Frm;
using WCS_Client.Models;
using WCS_Client.Utility;
using WCS_TASK = WCS_Client.Models.WCS_TASK;

namespace WCS_Client
{
    public enum TaskStatusType
    {
        重下堆垛机 = 1,
        重下输送机 = 2,
        重下RGV上料 = 3,
        重下RGV下料 = 4,
        重下任务 = 5
    }

    public enum WkStatus
    {
        未下发 = 0,
        未执行 = 1,
        输送机执行 = 2,
        RGV上料执行 = 3,
        RGV下料执行 = 4,
        堆垛机执行 = 5,
        完成任务 = 99,
        取消任务 = 106,
        手动过账 = 109
    }

    public enum TaskType
    {
        组盘 = 0,
        入库 = 1,
        出库 = 2,
        输送 = 5,
    }

    public class BaseWorkflow
    {
        public static bool Login(string use_No, string use_Pwd, out string errMsg)
        {
            bool result = false;
            errMsg = string.Empty;
            string errorMsg = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var user = db.Queryable<WCS_Users>().First(v => v.USER_NO == use_No);
                    if (user == null)
                    {
                        errorMsg = LangConst.UserNotExists;
                    }
                    else
                    {
                        if (user.USER_PWD == Md5Helper.Md5Hash(use_Pwd))
                        {
                            string user_textStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);

                            string jiemastr = BinaryHelper.jiema(user_textStr);
                            WCS_Users userinfo = jiemastr.ToObject<WCS_Users>();
                            userinfo.Use_LoginTime = DateTime.Now;
                            string userjson = userinfo.ToJson();

                            user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(BinaryHelper.bianma(userjson));
                            if (db.Updateable(user).UpdateColumns(it => it.USER_TEXT).ExecuteCommand() > 0)
                            {
                                user.GetUserInfo(userinfo);
                                CurrentHelper.User = user;
                                result = true;
                            }
                            else
                            {
                                errorMsg = LangConst.UpdateError;
                            }
                        }
                        else
                        {
                            errorMsg = LangConst.PasswordError;
                        }
                    }
                });

                //using (MAction action = new MAction(TableEnum.WCS_Users))
                //{
                //    MDataTable mdt = action.Select();
                //    var users = mdt.ToList<WCS_Users>();

                //    var user = users.FirstOrDefault(v => v.USER_NO == use_No);

                //    if (user == null)
                //    {
                //        errMsg = LangConst.UserNotExists;
                //    }
                //    else
                //    {
                //        if (user.USER_PWD == Md5Helper.Md5Hash(use_Pwd))
                //        {
                //            string user_textStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);

                //            string jiemastr = BinaryHelper.jiema(user_textStr);
                //            WCS_Users userinfo = jiemastr.ToObject<WCS_Users>();
                //            userinfo.Use_LoginTime = DateTime.Now;
                //            string userjson = userinfo.ToJson();

                //            user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(BinaryHelper.bianma(userjson));

                //            action.Set("USER_TEXT", user.USER_TEXT);
                //            string where = string.Format("USER_NO = '{0}'", user.USER_NO);
                //            if (action.Update(where, false))
                //            {
                //                user.GetUserInfo(userinfo);
                //                CurrentHelper.User = user;
                //                //CurrentHelper.User.UserInfoItem = BinaryHelper.jiema(CurrentHelper.User.User_Text).ToObject<UserInfo>();
                //                result = true;
                //            }
                //            else
                //            {
                //                errMsg = LangConst.UpdateError;
                //            }
                //        }
                //        else
                //        {
                //            errMsg = LangConst.PasswordError;
                //        }
                //    }
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                throw new Exception(LangConst.SysError);
            }
            return result;
        }

        public static PageData QueryDatatble(DataTable dt, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;
            try
            {
                int count = dt.Rows.Count;
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;
        }

        public static PageData QueryPageData(string _SQLText, string orderText, List<string> WhereStringList, int PageIndex, int PageSize)
        {
            var sb = new StringBuilder();
            sb.Append(_SQLText);
            if (WhereStringList != null && WhereStringList.Count > 0)
            {
                foreach (var item in WhereStringList)
                {
                    sb.Append(" and ");
                    sb.Append(item);
                }
            }
            return QueryPageSql(sb.ToString(), orderText, PageIndex, PageSize);
        }

        private static PageData QueryPageSql(string SQLText, string OrderText, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;

            string sql = string.Format("select * from (select ROW_NUMBER() Over (Order By {0}) as RN,a.* from ({1}) a) b where  b.RN between {2} and {3}", OrderText, SQLText, startRecord, endRecord);
            string CountStr = string.Format("Select Count(1) From ({0})  t", SQLText);
            try
            {
                DataTable dt = null;
                int count = 0;
                TryCachHelper.TryExecute((db) =>
                {
                    dt = db.Ado.GetDataTable(sql);
                    //新增列
                    string ADDRCURRENT = "ADDRCURRENT";
                    string ADDRline = "ADDRline";
                    dt.addDataColumn(new List<string> { ADDRCURRENT, ADDRline });
                    //获取当前所有任务对应的AGV任务
                    List<int> agvIDs = (from d in dt.AsEnumerable() select d.Field<int>("AgvTask")).Where(p => p > 0).ToList();
                    string ids = "";
                    agvIDs.ForEach(p =>
                    {
                        ids += p;
                        if (p != agvIDs[agvIDs.Count - 1]) ids += ",";
                    });
                    var _sql = $"select * from WCS_AGVTask where ID in ({ids})";
                    List<WCS_AGVTask> _AGVTASKs = db.SqlQueryable<WCS_AGVTask>(_sql).ToList();
                    //向新增列写入数据
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        //写入输送线
                        dt.Rows[i][ADDRCURRENT] = eqpData.deviceDataPack.StationDatas.Datas.Where(p => p.D521.TASKNUM == (int)dt.Rows[i][1] && p.D521.PH_STATUS).FirstOrDefault()?.Code;
                        //不在输送线，尝试写入RGV
                        if (string.IsNullOrEmpty(dt.Rows[i][ADDRCURRENT].ToString()))
                        {
                            dt.Rows[i][ADDRCURRENT] = eqpData.deviceDataPack.RGVDatas.Datas.Where(p => p.D521.TaskID == (int)dt.Rows[i][1] && p.D521.PH_Status).FirstOrDefault()?.Code;
                        }
                        //不在输送线/RGV，尝试写入堆垛机
                        if (string.IsNullOrEmpty(dt.Rows[i][ADDRCURRENT].ToString()))
                        {
                            dt.Rows[i][ADDRCURRENT] = eqpData.deviceDataPack.SCDatas.Datas.Where(p => p.D521.TaskID == (int)dt.Rows[i][1]).FirstOrDefault()?.Code;
                        }
                        var a = _AGVTASKs.Where(p => p.ID == (int)dt.Rows[i]["AgvTask"]).FirstOrDefault()?.Position;
                        //开始写入产线
                        dt.Rows[i][ADDRline] = _AGVTASKs.Where(p => p.ID == (int)dt.Rows[i]["AgvTask"]).FirstOrDefault()?.Position;

                        dt.AcceptChanges();
                    }

                    count = Convert.ToInt32(db.Ado.GetScalar(CountStr));
                });
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;
        }

        public static PageData QueryPageData2(string _SQLText, string orderText, List<string> WhereStringList, int PageIndex, int PageSize)
        {
            var sb = new StringBuilder();
            sb.Append(_SQLText);
            if (WhereStringList != null && WhereStringList.Count > 0)
            {
                sb.Append(" and ");
                sb.Append(WhereStringList[0]);
            }
            return QueryPageSql2(sb.ToString(), orderText, PageIndex, PageSize);
        }

        private static PageData QueryPageSql2(string SQLText, string OrderText, int PageIndex, int PageSize)
        {
            if (PageSize <= 0) PageSize = 2000;
            int startRecord = (PageIndex - 1) * PageSize + 1;
            int endRecord = startRecord + PageSize - 1;

            string sql = string.Format("select * from (select ROW_NUMBER() Over (Order By {0}) as RN,a.* from ({1}) a) b where  b.RN between {2} and {3}", OrderText, SQLText, startRecord, endRecord);
            string CountStr = string.Format("Select Count(1) From ({0})  t", SQLText);
            try
            {
                DataTable dt = null;
                int count = 0;
                TryCachHelper.TryExecute((db) =>
                {
                    List<WCS_Users> usersList = db.SqlQueryable<WCS_Users>(sql).ToList();
                    foreach (var item in usersList)
                    {
                        string binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                        string jsonstr = BinaryHelper.jiema(binaryStr);
                        var user = jsonstr.ToObject<WCS_Users>();
                        item.GetUserInfo(user);
                    }
                    dt = DatatableConvertHelper.ToDataTable(usersList);
                    count = Convert.ToInt32(db.Ado.GetScalar(CountStr));
                });
                //using (MProc proc = new MProc(sql))
                //{
                //    MDataTable mdt = proc.ExeMDataTable().ToDataTable();
                //    List<WCS_Users> usersList= mdt.ToList<WCS_Users>();
                //    foreach (var item in usersList)
                //    {
                //        string binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                //        string jsonstr = BinaryHelper.jiema(binaryStr);
                //        var user = jsonstr.ToObject<WCS_Users>();
                //        item.GetUserInfo(user);
                //    }
                //    dt = DatatableConvertHelper.ToDataTable(usersList);

                //    proc.ResetProc(CountStr);
                //    count = proc.ExeScalar<int>();
                //}
                int PageCount = count / PageSize;
                if (count % PageSize > 0)
                    PageCount += 1;

                if (dt != null && dt.Rows.Count > 0)
                {
                    PageData PageDataItem = new PageData();
                    PageDataItem.PageIndex = PageIndex;
                    PageDataItem.PageSize = PageSize;
                    PageDataItem.PageCount = PageCount;
                    PageDataItem.RowsCount = count;
                    dt.TableName = "table";
                    PageDataItem.Dt = dt;
                    return PageDataItem;
                }
            }
            catch (Exception ex)
            {
            }
            return null;
        }

        public static DataTable CommonQueryUser(string sql)
        {
            DataTable dt = null;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    List<WCS_Users> usersList = db.SqlQueryable<WCS_Users>(sql).ToList();
                    foreach (var item in usersList)
                    {
                        var binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                        string jsonstr = BinaryHelper.jiema(binaryStr);
                        var user = jsonstr.ToObject<WCS_Users>();
                        item.GetUserInfo(user);
                    }
                    dt = DatatableConvertHelper.ToDataTable(usersList);
                });
                //using (MProc prc = new MProc(sql))
                //{
                //    var mdt = prc.ExeMDataTable();
                //    List<WCS_Users> usersList = mdt.ToList<WCS_Users>();
                //    foreach (var item in usersList)
                //    {
                //        var binaryStr = BinaryHelper.ByteArray2BinaryStr(item.USER_TEXT);
                //        string jsonstr = BinaryHelper.jiema(binaryStr);
                //        var user = jsonstr.ToObject<WCS_Users>();
                //        item.GetUserInfo(user);
                //    }
                //    dt = DatatableConvertHelper.ToDataTable(usersList);
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return dt;
        }

        public static DataTable CommonQuery(string sql)
        {
            DataTable dt = null;
            TryCachHelper.TryExecute((db) =>
            {
                dt = db.Ado.GetDataTable(sql);
            });
            return dt;
        }

        public static string AddEditUser(WCS_Users user)
        {
            string result = string.Empty;
            try
            {
                if (user.USER_NO == LangConst.DefaultUser)
                {
                    result = LangConst.DefaultUserError;
                }
                else
                {
                    var json = user.ToJson();
                    string binarystr = BinaryHelper.bianma(json);
                    user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binarystr);
                    TryCachHelper.TryExecute((db) =>
                    {
                        var wcs_user = db.Queryable<WCS_Users>().First(v => v.USER_NO == user.USER_NO);
                        if (wcs_user == null)
                        {
                            //默认密码
                            user.USER_PWD = Md5Helper.Md5Hash(LangConst.DefaultPwd);
                            db.Insertable(user).ExecuteCommand();
                        }
                        else
                        {
                            wcs_user.USER_TEXT = user.USER_TEXT;
                            db.Updateable(wcs_user).UpdateColumns(it => it.USER_TEXT).ExecuteCommand();
                        }
                    });

                    //using (MAction action = new MAction(TableEnum.WCS_Users))
                    //{
                    //    if (action.Exists(user.USER_NO))
                    //    {
                    //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                    //        string where = string.Format("USER_NO = '{0}'", user.USER_NO);
                    //        action.Update(where, false);
                    //    }
                    //    else
                    //    {
                    //        //默认密码
                    //        user.USER_PWD = Md5Helper.Md5Hash(LangConst.DefaultPwd);
                    //        action.Set(WCS_UsersEnum.User_No, user.USER_NO);
                    //        action.Set(WCS_UsersEnum.User_Pwd, user.USER_PWD);
                    //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                    //        //插入信息
                    //        bool insertresult = action.Insert(InsertOp.None);
                    //    }
                    //}
                }
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = string.Format("{0}或{1}", LangConst.AddError, LangConst.UpdateError);
            }
            return result;
        }

        public static string DeleteUser(string user_no)
        {
            string result = string.Empty;
            try
            {
                if (user_no == LangConst.DefaultUser)
                {
                    result = LangConst.DefaultUserError;
                }
                else
                {
                    TryCachHelper.TryExecute((db) =>
                    {
                        db.Deleteable<WCS_Users>().Where(v => v.USER_NO == user_no).ExecuteCommand();
                    });
                }
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = LangConst.DeleteError;
            }
            return result;
        }

        public static string AdminModifyPwd(string user_no, string user_pwd)
        {
            string result = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var user = db.Queryable<WCS_Users>().First(v => v.USER_NO == user_no);
                    if (user == null)
                    {
                        result = LangConst.UserNotExists;
                    }
                    else
                    {
                        var binaryStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);
                        var useritem = BinaryHelper.jiema(binaryStr).ToObject<WCS_Users>();
                        useritem.Use_EditUserNo = CurrentHelper.User.USER_NO;
                        useritem.Use_EditDateTime = DateTime.Now;
                        var binStr = BinaryHelper.bianma(useritem.ToJson());
                        user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binStr);
                        user.USER_PWD = Md5Helper.Md5Hash(user_pwd);

                        db.Updateable(user).UpdateColumns(it => new { it.USER_TEXT, it.USER_PWD }).ExecuteCommand();
                    }
                });

                //using (MAction action = new MAction(TableEnum.WCS_Users))
                //{
                //    if (action.Exists(user_no))
                //    {
                //        MDataTable mdt = action.Select(user_no);
                //        var user = mdt.ToList<WCS_Users>()[0];
                //        var binaryStr = BinaryHelper.ByteArray2BinaryStr(user.USER_TEXT);
                //        var useritem = BinaryHelper.jiema(binaryStr).ToObject<WCS_Users>();
                //        useritem.Use_EditUserNo = CurrentHelper.User.USER_NO;
                //        useritem.Use_EditDateTime = DateTime.Now;
                //        // useritem.User_Pwd = Md5Helper.Md5Hash(user_pwd);
                //        var binStr = BinaryHelper.bianma(useritem.ToJson());
                //        user.USER_TEXT = BinaryHelper.BinaryStr2ByteArray(binStr);

                //        action.Set(WCS_UsersEnum.User_Pwd, Md5Helper.Md5Hash(user_pwd));
                //        action.Set(WCS_UsersEnum.User_Text, user.USER_TEXT);
                //        string where = string.Format("User_No = '{0}'", user.USER_NO);
                //        action.Update(where, false);
                //    }
                //    else
                //    {
                //        result = LangConst.UserNotExists;
                //    }
                //}
            }
            catch (Exception ex)
            {
                LogHelper.Sys_Log.WriteLog(ex.ToString());
                result = LangConst.UpdateError;
            }
            return result;
        }

        public static DataTable QuerySex()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='Sex'"));
        }

        public static DataTable QueryUse_Role()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='RoleId'"));
        }

        public static DataTable QueryTaskType()
        {
            return CommonQuery(string.Format("SELECT *  FROM WCS_Mappingentry where Mep_MappingType='COMTYPE'"));
        }

        public static void AddWCS_TASK_DTL(SqlSugarClient db, int task_id, int task_no, string posIdCur, string posIdNext, string msg)
        {
            var task_dtl = new WCS_TASK_DTL();
            task_dtl.ID = Guid.NewGuid().ToString();
            task_dtl.PARENTID = task_id;
            task_dtl.TASKNO = task_no.ToString();
            task_dtl.POSIDCUR = posIdCur;
            task_dtl.POSIDNEXT = posIdNext;
            task_dtl.DESCRIPTION = msg;
            task_dtl.EXECUTEDATE = DateTime.Now;
            db.Insertable(task_dtl).ExecuteCommand();
        }

        public static string UpdateTask(int taskid, TaskStatusType taskStatusType)
        {
            string result = string.Empty;
            try
            {
                TryCachHelper.TryExecute((db) =>
                {
                    var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == taskid);
                    if (taskStatusType == TaskStatusType.重下堆垛机)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行)
                        {
                            if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 3)//出库，移库
                            {
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                            }
                            else if (task.TASK_COMTYPE == 1)//入库
                            {
                                task.TASK_WKSTATUS = 2;
                            }
                            task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                            task.TASK_EDITDATETIME = DateTime.Now;
                            db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                            result = string.Format("任务[{0}]重下堆垛机成功。", task.TASK_NO);
                            AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                        }
                        else
                        {
                            result = string.Format("任务[{0}]不需要重下堆垛机。", task.TASK_NO);
                        }
                    }
                    else if (taskStatusType == TaskStatusType.重下输送机)
                    {
                        if (task.TASK_WKSTATUS != (int)WkStatus.堆垛机执行)
                        {
                            if (task.TASK_COMTYPE == 1 || task.TASK_COMTYPE == 4)//入库，移动
                            {
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;
                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重下输送机成功。");
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                            else
                            {
                                //出库，移库
                                result = string.Format("出库和移库任务[{0}]不能重下输送机。", task.TASK_NO);
                            }
                        }
                        else
                        {
                            result = string.Format("任务[{0}]状态为[堆垛机执行]不能重下输送机。", task.TASK_NO);
                        }
                    }
                    else if (taskStatusType == TaskStatusType.重下RGV上料 && task.TASK_WKSTATUS == (int)WkStatus.RGV上料执行)
                    {
                        task.TASK_WKSTATUS = 2;
                        task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                        task.TASK_EDITDATETIME = DateTime.Now;
                        db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();

                        var task_dtlSet = db.Queryable<WCS_TASK_DTL>().Where(v => v.PARENTID == task.TASK_NO).ToList();
                        var task_dtl = task_dtlSet.FirstOrDefault(v => v.DESCRIPTION.Contains("上料到RGV工位"));

                        int index = task_dtl.DESCRIPTION.IndexOf("上料到RGV工位");
                        int tempindex = task_dtl.DESCRIPTION.IndexOf('[', index);
                        string conveyerNo = task_dtl.DESCRIPTION.Substring(tempindex + 1, 4);
                        //解锁
                        db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK { ISLOCK = false }).Where(v => v.EQUIPMENTNO == conveyerNo).ExecuteCommand();

                        result = string.Format("任务[{0}]重下RGV上料成功。");
                        AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                    }
                    else if (taskStatusType == TaskStatusType.重下RGV下料 && task.TASK_WKSTATUS == (int)WkStatus.RGV下料执行)
                    {
                        var task_dtlSet = db.Queryable<WCS_TASK_DTL>().Where(v => v.PARENTID == task.TASK_NO).ToList();
                        var task_dtl = task_dtlSet.FirstOrDefault(v => v.DESCRIPTION.Contains("上料到RGV工位"));

                        task.TASK_WKSTATUS = 3;
                        task.TASK_POSIDNEXT = task_dtl.POSIDNEXT;
                        task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                        task.TASK_EDITDATETIME = DateTime.Now;
                        db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();

                        int index = task_dtl.DESCRIPTION.IndexOf("上料到RGV工位");
                        int tempindex = task_dtl.DESCRIPTION.IndexOf('[', index);
                        string conveyerNo = task_dtl.DESCRIPTION.Substring(tempindex + 1, 4);
                        //解锁
                        db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK { ISLOCK = false }).Where(v => v.EQUIPMENTNO == conveyerNo).ExecuteCommand();

                        result = string.Format("任务[{0}]重下RGV下料成功。", task.TASK_NO);
                        AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                    }
                    else if (taskStatusType == TaskStatusType.重下任务)
                    {
                        if (task.TASK_COMTYPE == 1)//入库
                        {
                            if (task.TASK_POSIDTO.Length < 10)
                            {
                                //未分配货位，可重下
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;

                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重新下发成功。", task.TASK_NO);
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                        }
                        else if (task.TASK_COMTYPE == 4)//移动
                        {
                            if (task.TASK_WKSTATUS == 0)
                            {
                                result = string.Format("任务[{0}]未下发，不需要重下任务。", task.TASK_NO);
                            }
                            else
                            {
                                //移动任务，可重下
                                task.TASK_WKSTATUS = 0;
                                task.TASK_POSIDNEXT = task.TASK_POSIDFROM;
                                task.TASK_POSIDCUR = task.TASK_POSIDFROM;
                                task.TASK_EDITUSERNO = CurrentHelper.User.USER_NO;
                                task.TASK_EDITDATETIME = DateTime.Now;

                                db.Updateable(task).UpdateColumns(it => new { it.TASK_WKSTATUS, it.TASK_POSIDNEXT, it.TASK_POSIDCUR, it.TASK_EDITUSERNO, it.TASK_EDITDATETIME }).ExecuteCommand();
                                result = string.Format("任务[{0}]重新下发成功。", task.TASK_NO);
                                AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDNEXT, result + "操作用户：" + CurrentHelper.User.USER_NO);
                            }
                        }
                        else if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 3)//出库,移库
                        {
                            result = string.Format("任务[{0}]是出库或移库任务，请使用[重下堆垛机]功能。", task.TASK_NO);
                        }
                    }

                    if (string.IsNullOrWhiteSpace(result))
                    {
                        throw new Exception(string.Format("任务[{0}]该状态下不支持[{1}]", task.TASK_NO, taskStatusType));
                    }
                });
            }
            catch (Exception ex)
            {
                result = ex.Message;
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return result;
        }

        public static string TaskFinish(string taskno)
        {
            string result = string.Empty;
            try
            {
                WCS_TASK task = null;

                TryCachHelper.TryExecute((db) =>
                {
                    int task_no = Convert.ToInt32(taskno);
                    task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                });

                if (task != null)
                {
                    if (task.TASK_COMTYPE == 1 || task.TASK_COMTYPE == 3)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行 && task.TASK_POSIDTO.Length > 10)
                        {
                            result = TaskComplete(task.TASK_NO, task.TASK_COMTYPE);
                        }
                        else
                        {
                            result = string.Format("任务[{0}]当前状态不可手动完成。", taskno);
                        }
                    }
                    else if (task.TASK_COMTYPE == 2 || task.TASK_COMTYPE == 4)
                    {
                        if (task.TASK_WKSTATUS == (int)WkStatus.堆垛机执行 || task.TASK_WKSTATUS <= 1)
                        {
                            result = string.Format("任务[{0}]当前状态不可手动完成。", taskno);
                        }
                        else
                        {
                            int tasktype = 4;
                            result = TaskComplete(task.TASK_NO, tasktype);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = ex.Message;
                LogHelper.Sys_Log.WriteLog(ex.ToString());
            }
            return result;
        }

        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="db"></param>
        /// <param name="conveyorOut">设备编号</param>
        /// <param name="taskno">任务号</param>
        /// <param name="temptype">类型  1：入库任务完成  2：堆垛机出库任务完成  3.移库完成 4：出库任务完成    5：任务取消 6：码盘 6：拆盘</param>
        public static string TaskComplete(int taskno, int temptype)
        {
            string result = string.Empty;
            string errorresult = TryCachHelper.TryExecute((db) =>
            {
                string status = "N";
                string MESSAGE = string.Empty;
                var outputResult = db.Ado.UseStoredProcedure<dynamic>(() =>
                {
                    string spName = "BZ_TASKCOMPLETE";
                    var p1 = new SugarParameter("@TEMPTASKNO", taskno);// 任务号
                    var p2 = new SugarParameter("@TEMPTYPE", temptype);//类型(出库任务完成)
                    var p3 = new SugarParameter("@STATUS", null, true);//反馈状态 Y:成功 N:失败
                    var p4 = new SugarParameter("@MESSAGE", null, true);//反馈消息

                    var dbResult = db.Ado.ExecuteCommand(spName, new SugarParameter[] { p1, p2, p3, p4 });
                    status = p3.Value.ToString();
                    MESSAGE = p4.Value.ToString();
                    return dbResult;
                });
                if (status.Trim().ToUpper() == "N")
                {
                    result = string.Format("任务[{0}]手动完成失败，传递参数:任务号[{1}]类型[{2}]反馈消息：[{3}]",
                            taskno, taskno, temptype, MESSAGE);
                }
                else
                {
                    result = string.Format("任务[{0}]手动完成成功。", taskno);
                }
            });
            if (!string.IsNullOrEmpty(errorresult)) result = errorresult;
            return result;
        }

        public static DateTime QuerySystemDate()
        {
            DateTime dt = DateTime.MinValue;
            TryCachHelper.TryExecute((db) =>
            {
                dt = db.Ado.GetDateTime("select sysdate from dual");
            });
            return dt;
        }

        public static void Equipment_UpdateLock(string equipmentNo, bool islock)
        {
            TryCachHelper.TryExecute((db) =>
            {
                db.Updateable<WCS_EQUIPMENTLOCK>().UpdateColumns(it => new WCS_EQUIPMENTLOCK() { ISLOCK = islock, UPDATETIME = DateTime.Now })
                                              .Where(it => it.EQUIPMENTNO == equipmentNo).ExecuteCommand();
            });
        }

        public static List<Frm.WCS_SC521> QueryStackerdDataDDJ(List<string> plcnameSet)
        {
            var stackerdDataSet = new List<Frm.WCS_SC521>();
            TryCachHelper.TryExecute((db) =>
            {
                stackerdDataSet = db.Queryable<Frm.WCS_SC521>().Where(v => plcnameSet.Contains(v.DEVICECODE) && v.ISLAST == true).ToList();
            });
            return stackerdDataSet;
        }

        public static List<Frm.WCS_RGV521> QueryStackerdDataRGV(List<string> plcnameSet)
        {
            var stackerdDataSet = new List<Frm.WCS_RGV521>();
            TryCachHelper.TryExecute((db) =>
            {
                stackerdDataSet = db.Queryable<Frm.WCS_RGV521>().Where(v => plcnameSet.Contains(v.DEVICECODE) && v.ISLAST == true).ToList();
            });
            return stackerdDataSet;
        }

        public static List<WCS_TASK> QueryTasks()
        {
            var tasks = new List<WCS_TASK>();
            TryCachHelper.TryExecute((db) =>
            {
                tasks = db.Queryable<WCS_TASK>().ToList();
            });
            return tasks;
        }

        public static void TaskUpdatePriority(SqlSugarClient db, int task_no, int priority)
        {
            if (db.Updateable<WCS_TASK>()
                  .UpdateColumns(it => new WCS_TASK
                  {
                      TASK_PRIORITY = priority,
                  })
                  .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
            {
                throw new Exception(string.Format("任务[{0}]修改优先级为[{0}]失败", task_no, priority));
            }
        }

        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="task_no"></param>
        /// <param name="finishType"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool BZ_TASKCOMPLETE(int task_no, int finishType, out string message)
        {
            message = string.Empty;
            return true;
        }

        /// <summary>
        /// 任务取消
        /// </summary>
        /// <param name="task_no">任务号</param>
        /// <param name="msg">消息</param>
        /// <returns>是否取消成功</returns>
        public static bool TaskCancel(int task_no, out string msg)
        {
            msg = string.Empty;
            return true;
        }

        public static string RestartTask(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<Frm.WCS_TASK>().First(v => v.ID == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TYPE == Frm.TaskType.出库 && task.STATUS > 0 && task.STATUS < 99)
                    {
                        if (db.Updateable<Frm.WCS_TASK>()
                              .UpdateColumns(it => new Frm.WCS_TASK
                              {
                                  STATUS = 0,
                                  UPDATETIME = DateTime.Now
                              })
                              .Where(v => v.ID == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]重置失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不是出库任务或者是已完成的出库不能执行[重下任务]", task_no));
                    }
                }
            });
            return result;
        }

        public static string SrmInfoSet(string convNo, bool isStop)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var srmoutinInfo = db.Queryable<WCS_SRMOUTININFO>().First(v => v.SRMOUTIN_CONVNO == convNo);
                if (srmoutinInfo == null)
                {
                    throw new Exception(string.Format("未查询到堆垛机出入口[{0}]信息", convNo));
                }
                else
                {
                    if (db.Updateable<WCS_SRMOUTININFO>()
                          .UpdateColumns(it => new WCS_SRMOUTININFO
                          {
                              SRMOUTIN_ISSTOP = isStop,
                              SRMOUTIN_ISUPDATE = true
                          })
                          .Where(v => v.SRMOUTIN_CONVNO == convNo).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("堆垛机出入口[{0}]禁(启)用失败", convNo));
                    }
                    //else
                    //{
                    //    //与AGV共口也需禁用掉
                    //    var rgvoutinInfo = db.Queryable<WCS_RGVOutInInfo>().First(v => v.RGVOUTIN_CONVNO == convNo);
                    //    if (rgvoutinInfo != null)
                    //    {
                    //        if (db.Updateable<WCS_RGVOutInInfo>()
                    //             .UpdateColumns(it => new WCS_RGVOutInInfo
                    //             {
                    //                 RGVOUTIN_ISSTOP = isStop
                    //             })
                    //             .Where(v => v.RGVOUTIN_CONVNO == convNo).ExecuteCommand() < 0)
                    //        {
                    //            throw new Exception(string.Format("AGV出入口[{0}]禁(启)用失败", convNo));
                    //        }
                    //    }
                    //}
                }
            });
            return result;
        }

        public static string OnUpMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 7)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 2,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_ITEM4,
                                  TASK_POSIDNEXT = task.TASK_ITEM4,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]上下料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[上下料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }

        public static string OnMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 3)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 2,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_POSIDNEXT,
                                  TASK_EDITUSERNO = "wcs",
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]上料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[上料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }

        public static string UpMatRestart(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_WKSTATUS == 4)
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_WKSTATUS = 3,
                                  TASK_RGVNO = "",
                                  TASK_POSIDCUR = task.TASK_RGVNO,
                                  TASK_POSIDNEXT = task.TASK_ITEM4,//起点地址
                                  TASK_EDITUSERNO = "wcs",
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]下料重下RGV失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]不能执行[下料重下RGV].", task_no));
                    }
                }
            });
            return result;
        }

        public static string FinishTask(int task_no)
        {
            string result = TryCachHelper.TryExecute((db) =>
            {
                var task = db.Queryable<Frm.WCS_TASK>().First(v => v.ID == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.STATUS > 1)
                    {
                        if (db.Updateable<Frm.WCS_TASK>()
                             .UpdateColumns(it => new Frm.WCS_TASK
                             {
                                 STATUS = 99,
                                 UPDATEUSER = CurrentHelper.User.USER_NO,
                                 UPDATETIME = DateTime.Now
                             })
                             .Where(v => v.ID == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]手动完成失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]未执行,不能执行[手动完成].", task_no));
                    }
                }
            });
            return result;
        }

        public static string ClearTask(int task_no)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var task = db.Queryable<Frm.WCS_TASK>().First(v => v.ID == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.STATUS < 99)
                    {
                        if (db.Updateable<Frm.WCS_TASK>()
                              .UpdateColumns(it => new Frm.WCS_TASK
                              {
                                  STATUS = 106,
                                  UPDATETIME = DateTime.Now
                              })
                              .Where(v => v.ID == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]取消失败", task_no));
                        }
                    }
                    else
                    {
                        throw new Exception(string.Format("任务[{0}]已完成或已取消，不能执行取消动作。", task_no));
                    }
                }
            });
            return result;
        }

        public static string UdpateEndAddress(int task_no, string whid, string srm)
        {
            string nextAddress = string.Empty;
            var dicSet = new Dictionary<string, string>();

            string result = TryCachHelper.TryTranExecute((db) =>
            {
                if (string.IsNullOrWhiteSpace(srm))
                {
                    throw new Exception(string.Format("请选择要变更的堆垛机"));
                }
                if (whid == "原料库")
                {
                    dicSet.Add("srm01", "1092");
                    dicSet.Add("srm02", "1094");
                    dicSet.Add("srm03", "1096");
                    dicSet.Add("srm04", "1098");
                    dicSet.Add("srm05", "1100");
                }
                else if (whid == "成品库")
                {
                    dicSet.Add("srm06", "2324");
                    dicSet.Add("srm07", "2320");
                    dicSet.Add("srm08", "2316");
                    dicSet.Add("srm09", "2312");
                    dicSet.Add("srm10", "2308");
                    dicSet.Add("srm11", "2304");
                }
                else
                {
                    throw new Exception(string.Format("仓库[{0}]错误。", whid));
                }
                nextAddress = dicSet[srm];

                var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到[{0}]信息", task_no));
                }
                else
                {
                    if (task.TASK_POSIDTO.Length >= 10)
                    {
                        throw new Exception(string.Format("任务[{0}]已经分配货位，不能变更目标地址。", task_no));
                    }
                    else
                    {
                        if (db.Updateable<WCS_TASK>()
                              .UpdateColumns(it => new WCS_TASK
                              {
                                  TASK_POSIDNEXT = nextAddress,
                                  TASK_POSIDTO = srm,
                                  TASK_SRMNO = srm,
                                  TASK_EndTunnelNum = srm,
                                  TASK_EDITUSERNO = CurrentHelper.User.Use_Name,
                                  TASK_EDITDATETIME = DateTime.Now
                              })
                              .Where(v => v.TASK_NO == task_no).ExecuteCommand() < 0)
                        {
                            throw new Exception(string.Format("任务[{0}]修改目标地址失败", task_no));
                        }
                        string msg = string.Format("任务[{0}]手动修改下个地址为[{1}]目标地址为[{2}]成功。", task_no, nextAddress, srm);
                        var task_dtl = new WCS_TASK_DTL();
                        task_dtl.ID = Guid.NewGuid().ToString();
                        task_dtl.PARENTID = task_no;
                        task_dtl.TASKNO = task_no.ToString();
                        task_dtl.POSIDCUR = task.TASK_POSIDCUR;
                        task_dtl.POSIDNEXT = nextAddress;
                        task_dtl.DESCRIPTION = msg;
                        task_dtl.EXECUTEDATE = DateTime.Now;
                        db.Insertable(task_dtl).ExecuteCommand();
                    }
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("任务[{0}]修改下个地址为[{1}]目标地址为[{2}]成功。", task_no, nextAddress, srm);
            }
            return result;
        }

        public static string UpdateTaskPriority(int task_no, int priority)
        {
            string result = TryCachHelper.TryTranExecute((db) =>
            {
                var task = db.Queryable<Frm.WCS_TASK>().First(v => v.ID == task_no);
                if (task == null)
                {
                    throw new Exception(string.Format("未查询到WCS任务[{0}]信息", task_no));
                }
                else
                {
                    if (db.Updateable<Frm.WCS_TASK>()
                          .UpdateColumns(it => new Frm.WCS_TASK
                          {
                              Priority = priority,
                              UPDATEUSER = CurrentHelper.User.Use_Name,
                              UPDATETIME = DateTime.Now
                          })
                          .Where(v => v.ID == task_no).ExecuteCommand() < 0)
                    {
                        throw new Exception(string.Format("WCS任务[{0}]调整优先级失败", task_no));
                    }
                    string msg = string.Format("任务[{0}]调整优先级为[{1}]成功。", task_no, priority);
                }
            });
            if (string.IsNullOrWhiteSpace(result))
            {
                result = string.Format("任务[{0}]调整优先级[{1}]成功。", task_no, priority);
            }
            return result;
        }
    }

    public class WCS_SCANN
    {
        [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
        public string SCANN_ID { get; set; }

        /// <summary>
        /// 扫描位置编号
        /// </summary>
        public string SCANN_STATIONNO { get; set; }

        /// <summary>
        /// 扫描到的条码
        /// </summary>
        public string SCANN_BARCODE { get; set; }

        /// <summary>
        /// 顺序
        /// </summary>
        public int SCANN_SEQUENCE { get; set; }

        /// <summary>
        /// PLC名称
        /// </summary>
        public string SCANN_PLCNAME { get; set; }

        /// <summary>
        /// 起点地址
        /// </summary>
        public int SCANN_STARTADDRESS { get; set; }

        /// <summary>
        /// 扫描长度
        /// </summary>
        public int SCANN_LENGTH { get; set; }

        public int SCANN_DB_ID { get; set; }
        public int SCANN_VALIDTIMEINTERVAL { get; set; }

        public DateTime SCANN_UPDATETIME { get; set; }
        public DateTime SYSDATE { get; set; }
    }
}