using FineUIPro;
using Model;
using Newtonsoft.Json;
using Quartz;
using RestSharp;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace BLL
{
 
    public static class  InterFaceTaskService 
    {
         public static Model.SGGLDB db = Funs.DB;
         
 
          #region 获取列表
        /// <summary>
        /// 记录数
        /// </summary>
        public static int count
        {
            get;
            set;
        }
         public static List<Model.InterFaceTask> GetInterFaceTaskByModle(Model.InterFaceTask table)
   		{
               var q= from x in db.InterFaceTask
               where  
                         ( string.IsNullOrEmpty(table.InterFaceTaskId)||x.InterFaceTaskId.Contains(table.InterFaceTaskId)) &&
                         ( string.IsNullOrEmpty(table.InterFaceName)||x.InterFaceName.Contains(table.InterFaceName)) &&
                         ( string.IsNullOrEmpty(table.InterFaceSetLists)||x.InterFaceSetLists.Contains(table.InterFaceSetLists)) &&
                         ( string.IsNullOrEmpty(table.Frequency)||x.Frequency.Contains(table.Frequency)) &&
                         (table.Enable ==null|| x.Enable==table.Enable)
                      select x 
                     ;
                     
              return q.ToList();
        }

        /// 获取分页列表
        /// </summary>
        /// <param name="PageIndex">页码</param>
        /// <param name="PageSize">每页数量</param>
        /// <returns></returns>
        public static IEnumerable getListData(Model.InterFaceTask table, Grid Grid1)
        {
            var  q= GetInterFaceTaskByModle(table);
            count = q.Count();
            if (count == 0)
            {
                return null;
            }
            //  q=  q.Take(Grid1.PageSize * Grid1.PageIndex).Skip(Grid1.PageSize * (Grid1.PageIndex)).ToList();
           // q = SortConditionHelper.SortingAndPaging(q, Grid1.SortField, Grid1.SortDirection, Grid1.PageIndex, Grid1.PageSize);
            return from x in q
                   select new
                   {
                          x.InterFaceTaskId,
                          x.InterFaceName,
                          x.InterFaceSetLists,
                          x.Frequency,
                          x.CreateTime,
                          x.Enable,
                        
                   };
        }
        #endregion

        public static Model.InterFaceTask  GetInterFaceTaskById(string InterFaceTaskId)
   		{
           return db.InterFaceTask.FirstOrDefault(x=>x.InterFaceTaskId==InterFaceTaskId);
        }
        public static void AddInterFaceTask(Model.InterFaceTask newtable)
        {
        
            Model.InterFaceTask table = new Model.InterFaceTask{
                 InterFaceTaskId=newtable.InterFaceTaskId,
                 InterFaceName=newtable.InterFaceName,
                 InterFaceSetLists=newtable.InterFaceSetLists,
                 Frequency=newtable.Frequency,
                 CreateTime=newtable.CreateTime,
                 Enable=newtable.Enable,
            };
            db.InterFaceTask.InsertOnSubmit(table);
            db.SubmitChanges();
        }

 
        public static void UpdateInterFaceTask(Model.InterFaceTask newtable)
        {
            
            Model.InterFaceTask table = db.InterFaceTask.FirstOrDefault(x=>x.InterFaceTaskId==newtable.InterFaceTaskId);
       		if (table != null)
            {
                table.InterFaceTaskId=newtable.InterFaceTaskId;
                table.InterFaceName=newtable.InterFaceName;
                table.InterFaceSetLists=newtable.InterFaceSetLists;
                table.Frequency=newtable.Frequency;
                table.CreateTime=newtable.CreateTime;
                table.Enable=newtable.Enable;
                db.SubmitChanges();
            }
            
        }
        public static  void  DeleteInterFaceTaskById (string InterFaceTaskId)
        {   
             
              Model.InterFaceTask table =db.InterFaceTask.FirstOrDefault(x=>x.InterFaceTaskId==InterFaceTaskId);
              if (table != null)
              {
                db.InterFaceTask.DeleteOnSubmit(table);
                db.SubmitChanges();
              }
             
        }
        #region 执行任务
        public static void ExecuteTasks(string InterFaceTaskId)
        {
            
            var model = GetInterFaceTaskById(InterFaceTaskId);
            var InterFaceSetlIds = model.InterFaceSetLists.Split(',');
            foreach (var item in InterFaceSetlIds)
            {
                ExecuteTasksByInterFaceSetlId(item);

            }
        }
        /// <summary>
        /// 执行接口
        /// </summary>
        /// <param name="InterFaceSetlId">接口id </param>
        public static void ExecuteTasksByInterFaceSetlId(string InterFaceSetlId)
        {
            var InterfaceSetModel = InterFaceSetService.GetInterFaceSetById(InterFaceSetlId);
            if (InterfaceSetModel == null)
            {
                return;
            }
            try
            {

                var sourseData = GetSourseData(InterfaceSetModel.InterFaceUrl, InterfaceSetModel.UrlReqMethod);
                bool sourseisSuccess = false;
                if (sourseData.code == 1)
                {
                    sourseisSuccess = true;
                }
                InterFaceLogService.WriteInterFaceLog(InterFaceSetlId, "", JsonConvert.SerializeObject(sourseData), InterFaceLogService.Type1, sourseisSuccess);
                if (sourseData.code == 0)
                {
                    return;
                }
                var TargetData = GetTargetData(InterfaceSetModel.InterFaceForUrl, sourseData, InterfaceSetModel.ForUrlReqMethod);

                bool TargetisSuccess = false;
                if (TargetData.code == 1)
                {
                    TargetisSuccess = true;
                }
                InterFaceLogService.WriteInterFaceLog(InterFaceSetlId, JsonConvert.SerializeObject(sourseData.data), JsonConvert.SerializeObject(TargetData), InterFaceLogService.Type2, TargetisSuccess);

                if (TargetData.code == 0 || InterfaceSetModel.IsCallBack == false)
                {
                    return;
                }
                var callbackData = ExecuteCallBack(InterfaceSetModel.InterFaceCallBackUrl, sourseData, InterfaceSetModel.CallBackUrlReqMethod);

                bool CallBackisSuccess = false;
                if (TargetData.code == 1)
                {
                    CallBackisSuccess = true;
                }
                InterFaceLogService.WriteInterFaceLog(InterFaceSetlId, JsonConvert.SerializeObject(sourseData.data), JsonConvert.SerializeObject(callbackData), InterFaceLogService.Type3, CallBackisSuccess);

            }
            catch (Exception ex )
            {
                Model.InterFaceLog interFaceLog=new InterFaceLog();
                interFaceLog.InterFaceLogId=Guid.NewGuid().ToString();
                interFaceLog.InterFaceType = "异常";
                interFaceLog.LogSate = false;
                interFaceLog.InterFaceLogDate= DateTime.Now;
                interFaceLog.InterFaceName = InterfaceSetModel.InterFaceName;
                interFaceLog.InterFaceReturnData = ex.ToString();
                InterFaceLogService.AddInterFaceLog(interFaceLog);
            }
       
        }
        public static Model.ReturnData GetSourseData(string baseurl,string ReqMethod)
        {
            Model.ReturnData returnData = new ReturnData();
            string token = "C4A62EC0-E5D3-4EBF-A5FA-E56AA89633C0";
            string Content = "";
            switch (ReqMethod)
            {
                case  "Get":
                    Content = Funs.RequestGet(baseurl, token);
                    break;
                case "Post":
                    Content = Funs.RequestPost(baseurl, token, "");
                    break;
            }
            //var client = new RestClient(baseurl);
            //client.Timeout = -1;
            //var request = new RestRequest(Method.POST);
            //request.AddHeader("token", "AF17168B-87BD-4GLY-1111-F0A0A1158F9B");
            //IRestResponse response = client.Execute(request);
            //Console.WriteLine(response.Content);
            try
            {
                returnData = JsonConvert.DeserializeObject<Model.ReturnData>(Content);
            }
            catch (Exception)
            {
                returnData.code = 0;
                returnData.message = "获取数据失败：" + Content;
            }


            return returnData;
        }
        public static Model.ResponeData GetTargetData(string baseurl, ReturnData DataInput, string ReqMethod)
        {
            Model.ResponeData responeData = new ResponeData();
            if (DataInput.code == 1)
            {

                string token = DataInput.token;
                string returnContent = "";
                switch (ReqMethod)
                {
                    case "Get":
                        returnContent = Funs.RequestGet(baseurl, token);
                        break;
                    case "Post":
                        returnContent = Funs.RequestPost(baseurl, token, JsonConvert.SerializeObject(DataInput.data));
                        break;
                }
                //var client = new RestClient(baseurl);
                //client.Timeout = -1;
                //if (isPost)
                //{
                //    var request = new RestRequest(Method.POST);
                //    request.AddHeader("token", DataInput.token);
                //    request.AddJsonBody(JsonConvert.SerializeObject(DataInput.data));
                //    IRestResponse response = client.Execute(request);
                //    returnContent = response.Content;

                //}
                //else
                //{
                //    var request = new RestRequest(Method.GET);
                //    request.AddHeader("token", DataInput.token);
                //    IRestResponse response = client.Execute(request);
                //    returnContent = response.Content;

                //}
                try
                {
                    responeData = JsonConvert.DeserializeObject<Model.ResponeData>(returnContent);
                }
                catch (Exception)
                {
                    responeData.code = 0;
                    responeData.message = "推送数据失败：" + returnContent;

                }
                return responeData;
            }
            else
            {

            }
            return responeData;
        }
        public static ReturnData ExecuteCallBack(string baseurl, ReturnData DataInput,string ReqMethod)
        {
            Model.ReturnData returnData = new ReturnData();
            if (DataInput.code == 1)
            {
                string token = "AF17168B-87BD-4GLY-1111-F0A0A1158F9B";
                string Content = "";
                switch (ReqMethod)
                {
                    case "Get":
                        Content = Funs.RequestGet(baseurl, token);
                        break;
                    case "Post":
                        Content = Funs.RequestPost(baseurl, token, JsonConvert.SerializeObject(DataInput.data));
                        break;
                }

                //var client = new RestClient(baseurl);
                //client.Timeout = -1;
                //var request = new RestRequest(Method.POST);
                //request.AddHeader("token", "AF17168B-87BD-4GLY-1111-F0A0A1158F9B");
                //request.AddJsonBody(JsonConvert.SerializeObject(DataInput.data));
                //IRestResponse response = client.Execute(request);
                //returnContent = response.Content;
                try
                {
                    returnData = JsonConvert.DeserializeObject<Model.ReturnData>(Content);
                }
                catch (Exception)
                {
                    returnData.code = 0;
                    returnData.message = "回调失败：" + Content;

                }

            }
            return returnData;
        }
        #endregion


    }
}