using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace VRS.Handler
{
    /// <summary>
    /// Boat 的摘要说明
    /// </summary>
    public class Boat : BaseHandler, IHttpHandler
    {
        DataService.BLL.admin_user bll_user = new DataService.BLL.admin_user();

        DataService.BLL.pro_exam_batch bll_exam_batch = new DataService.BLL.pro_exam_batch();
        DataService.BLL.pro_lianxi_batch bll_lianxi_batch = new DataService.BLL.pro_lianxi_batch();

        DataService.BLL.pro_examination bll_examination = new DataService.BLL.pro_examination();

        DataService.BLL.pro_exam_theory bll_pro_exam_theory = new DataService.BLL.pro_exam_theory();
        DataService.BLL.pro_theory_base bll_theory_base = new DataService.BLL.pro_theory_base();
        DataService.BLL.pro_theory_base_item bll_base_item = new DataService.BLL.pro_theory_base_item();

        DataService.BLL.pro_exam_batch_result bll_batch_result = new DataService.BLL.pro_exam_batch_result();
        DataService.BLL.pro_exam_batch_result_detail bll_batch_result_detail = new DataService.BLL.pro_exam_batch_result_detail();

        DataService.BLL.admin_school bll_school = new DataService.BLL.admin_school();

        DataService.BLL.pro_theory_base_cache bll_base_cache = new DataService.BLL.pro_theory_base_cache();

        DataService.BLL.pro_theory_base_cache_item bll_base_cache_item = new DataService.BLL.pro_theory_base_cache_item();



        DataService.BLL.pro_type_manage bll_type_manage = new DataService.BLL.pro_type_manage();


        public void ProcessRequest(HttpContext context)
        {
            baseContext = context;
            context.Response.ContentType = "application/json";
            CrossDomain();
            if (null == context.Request["action"])
            {
                var result = GetResult(false, "缺少参数：action");
                context.Response.Write(result);
                context.Response.End();
            }
            string action = context.Request["action"];
            switch (action)
            {
                //查询所有船型
                case "all":
                    ALL(context);
                    break;

                //查询理论试题列表
                case "theorylist":
                    QueryTheoryListInfo(context);
                    break;

                //查询理论试题列表
                case "theorybase":
                    QueryTheoryBaseInfo(context);
                    break;

                //保存理论成绩
                case "savetheory":
                    SaveTheoryExam(context);
                    break;

                //保存练习考试成绩
                case "savelianxi":
                    SaveTheoryExam_Lianxi(context);
                    break;

                //查询练习考试列表包含总成绩
                case "querylianxilist":
                    QueryExamLianxiList(context);
                    break;

                //查询单个练习考试
                case "querylianxiresult":
                    QueryExamLianxiResult(context);
                    break;

                //查询单个练习考试详情
                case "querylianxidetails":
                    QueryLianxiResultDetail(context);
                    break;

                //保存理论缓存
                case "savetheorycache":
                    SaveTheoryCache(context);
                    break;

                //获取理论缓存
                case "gettheorycache":
                    GetTheoryCache(context);
                    break;

                //获取服务器时间
                case "servertime":
                    GetServerTime(context);
                    break;

                //获取id
                case "getid":
                    GetId(context);
                    break;

                //获取用户
                case "queryuser":
                    QueryUser(context);
                    break;

                //获取科目类别
                case "GetSubjectType":
                    GetSubjectType(context);
                    break;

                default:
                    var result = GetResult(false, "方法名不存在：" + action);
                    context.Response.Write(result);
                    break;
            }
        }
        /// <summary>
        /// 获取科目类别
        /// </summary>
        /// <param name="context"></param>
        public void GetSubjectType(HttpContext context)
        {
            var list = bll_type_manage.GetModelList(" parent_id='SubjectType' ").Select(s => s.type_name).ToList();
            var result = GetResult(true, list);
            context.Response.Write(result);
            context.Response.End();
        }

        /// <summary>
        /// 查询所有船型
        /// </summary>
        /// <param name="context"></param>
        public void ALL(HttpContext context)
        {
            var list_sign_boat = BasePage.list_sign_boat;
            var result = GetResult(true, list_sign_boat);
            context.Response.Write(result);
            context.Response.End();
        }


        /// <summary>
        /// 查询该批次的试题列表
        /// </summary>
        /// <param name="context"></param>
        public void QueryTheoryListInfo(HttpContext context)
        {
            var ret = string.Empty;
            var batch_id = context.Request.Params["batch_id"];
            if (string.IsNullOrEmpty(batch_id))
            {
                ret = GetResult(false, "batch_id不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            var exam_id = "";
            var lianxi = context.Request.Params["lianxi"];
            if (lianxi == "1")
            {
                var batch_lianxi = bll_lianxi_batch.GetModel(batch_id);
                if (null == batch_lianxi)
                {
                    ret = GetResult(false, "练习批次不存在, batch_id:" + batch_id);
                    context.Response.Write(ret);
                    context.Response.End();
                }
                exam_id = batch_lianxi.exam_id;
            }
            else
            {
                var batch = bll_exam_batch.GetModel(batch_id);
                if (null == batch)
                {
                    ret = GetResult(false, "考试批次不存在, batch_id:" + batch_id);
                    context.Response.Write(ret);
                    context.Response.End();
                }
                exam_id = batch.exam_id;
            }

            //question_difficult 0 判断题  1 单选题 2 多选题 3 填空题 4 简答题
            var question_difficult = context.Request.Params["kind"];
            //var exam = bll_examination.GetModel(batch.exam_id);
            var exam = bll_examination.GetModel(exam_id);
            var qry = "exam_id = '" + exam.id + "' ";

            if (!string.IsNullOrEmpty(question_difficult))
            {
                qry = qry + " and question_difficult='" + question_difficult + "' ";
            }

            var exam_theory_list = bll_pro_exam_theory.GetModelList(qry).OrderBy(s => s.question_difficult).ThenBy(s => s.no).ToList();
            List<theory_base_response> list = new List<theory_base_response>();
            foreach (var item in exam_theory_list)
            {
                var obj = new theory_base_response();
                obj.question_kind = item.question_kind;
                //obj.question_difficult = item.question_difficult;
                obj.per_score = item.per_score.Value;
                obj.no = item.no;
                obj.theory_base_id = item.content;

                #region new added
                var theory_base = bll_theory_base.GetModel(item.content);
                if (null != theory_base)
                {
                    obj.question = theory_base.question;
                    obj.answer = theory_base.answer;
                }
                #endregion

                list.Add(obj);
            }
            var result = GetResult(true, list);
            context.Response.Write(result);
            context.Response.End();
        }


        /// <summary>
        /// 查询该批次的试题列表
        /// </summary>
        /// <param name="context"></param>
        public void QueryTheoryBaseInfo(HttpContext context)
        {
            var ret = string.Empty;
            var id = context.Request.Params["theory_base_id"];
            if (string.IsNullOrEmpty(id))
            {
                ret = GetResult(false, "id不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            var theory_base = bll_theory_base.GetModel(id);
            if (null == theory_base)
            {
                ret = GetResult(false, "题目不存在, id:" + id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var base_item_list = bll_base_item.GetModelList("theory_base_id='" + id + "'").OrderBy(s => s.no).ToList();
            List<theory_base_item_response> list = new List<theory_base_item_response>();
            foreach (var item in base_item_list)
            {
                var obj = new theory_base_item_response();
                obj.no = item.no.Value;
                obj.item_letter = item.item_letter;
                obj.item = item.item;
                list.Add(obj);
            }
            var back = new theory_base_item_response_full();
            back.question = theory_base.question;
            back.answer = theory_base.answer;
            back.items = list;
            var result = GetResult(true, back);
            context.Response.Write(result);
            context.Response.End();
        }

        public class theory_base_item_response_full
        {
            public string question { get; set; }

            public string answer { get; set; }
            public List<theory_base_item_response> items { get; set; }
        }

        /// <summary>
        /// 查询单个考试详情
        /// </summary>
        /// <param name="context"></param>
        public void QueryExamLianxiResult(HttpContext context)
        {
            // bll_batch_result
            var ret = string.Empty;
            var result_id = context.Request.Params["result_id"];
            if (string.IsNullOrEmpty(result_id))
            {
                ret = GetResult(false, "result_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            var obj = bll_batch_result.GetModel(result_id);
            if (null == obj)
            {
                ret = GetResult(false, "考试记录不存在，result_id：" + result_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var exam = bll_examination.GetModel(obj.exam_id);
            if (null != exam)
            {
                obj.pass_score = exam.pass_score;
            }
            ret = GetResult(true, obj);
            context.Response.Write(ret);
            context.Response.End();
        }

        /// <summary>
        /// 查询练习考试列表
        /// </summary>
        /// <param name="context"></param>
        public void QueryExamLianxiList(HttpContext context)
        {
            // bll_batch_result
            var ret = string.Empty;
            var user_id = context.Request.Params["user_id"];
            if (string.IsNullOrEmpty(user_id))
            {
                ret = GetResult(false, "user_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            var batch_id = context.Request.Params["batch_id"];
            if (string.IsNullOrEmpty(batch_id))
            {
                ret = GetResult(false, "batch_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", batch_id, user_id);
            var list = bll_batch_result.GetModelList(qry).OrderByDescending(s => s.result_id).ToList();
            List<ListLianxiRespnse> list_back = new List<ListLianxiRespnse>();

            foreach (var item in list)
            {
                ListLianxiRespnse obj = new ListLianxiRespnse();
                obj.result_id = item.result_id;
                obj.examine_time = item.examine_time;
                obj.total = item.total;
                obj.score = item.score;
                var exam = bll_examination.GetModel(item.exam_id);
                if (null != exam)
                {
                    obj.exam_id = exam.id;
                    obj.exam_name = exam.exam_name;
                    obj.pass_score = exam.pass_score;
                }
                else
                {
                    obj.exam_id = item.exam_id;
                    obj.exam_name = item.exam_name;
                }

                list_back.Add(obj);
            }
            ret = GetResult(true, list_back);
            context.Response.Write(ret);
            context.Response.End();
        }

        public class ListLianxiRespnse
        {
            public DateTime? examine_time { get; set; }
            public string result_id { get; set; }
            public decimal total { get; set; }
            public decimal score { get; set; }

            #region  试卷id、名称、及格分数
            public string exam_id { get; set; }
            public string exam_name { get; set; }
            public decimal? pass_score { get; set; }
            #endregion
        }
        /// <summary>
        /// 查询用户
        /// </summary>
        /// <param name="context"></param>
        public void QueryUser(HttpContext context)
        {
            var ret = string.Empty;
            var user_id = context.Request.Params["user_id"];
            if (string.IsNullOrEmpty(user_id))
            {
                ret = GetResult(false, "user_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            var model = bll_user.GetModel(user_id);
            if (null == model)
            {
                ret = GetResult(false, "用户不存在，user_id：" + user_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var user = new
            {
                user_id = model.user_id,
                real_name = model.real_name,
                login_name = model.login_name
            };
            ret = GetResult(true, user);
            context.Response.Write(ret);
            context.Response.End();
        }

        public void QueryLianxiResultDetail(HttpContext context)
        {
            var ret = string.Empty;
            var result_id = context.Request.Params["result_id"];
            if (string.IsNullOrEmpty(result_id))
            {
                ret = GetResult(false, "result_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            var qry = " result_id='" + result_id + "' ";
            var question_difficult = context.Request.Params["question_difficult"];
            if (!string.IsNullOrEmpty(question_difficult))
            {
                qry = qry + " and question_difficult='" + question_difficult + "' ";
            }
            var data = bll_batch_result_detail.GetModelList(qry).OrderBy(s => s.question_difficult).ThenBy(s => s.no).ToList();
            foreach (var item in data)
            {
                item.right_answer_desc = new List<string>();
                item.your_answer_desc = new List<string>();

                if (item.is_right == 1)
                {
                    item.result_desc = "对";
                }
                else if (item.is_right == 0)
                {
                    item.result_desc = "错";
                }
                else if (item.is_right == 2)
                {
                    item.result_desc = "缺";
                }

                if (item.kind == "填空题")
                {

                    if (item.right_answer.Contains("__"))
                    {
                        var array = item.right_answer.Split(new string[] { "__" }, StringSplitOptions.None);
                        foreach (var sub in array)
                        {
                            var temp = sub.Replace("null", "").Replace("Null", "").Replace("NULL", "");
                            item.right_answer_desc.Add(temp);
                        }
                    }
                    else
                    {
                        item.right_answer_desc.Add(item.right_answer);
                    }

                    if (item.your_answer.Contains("__"))
                    {
                        var array = item.your_answer.Split(new string[] { "__" }, StringSplitOptions.None);
                        foreach (var sub in array)
                        {
                            var temp = sub.Replace("null", "").Replace("Null", "").Replace("NULL", "");
                            item.your_answer_desc.Add(temp);
                        }
                    }
                    else
                    {
                        item.your_answer_desc.Add(item.your_answer);
                    }
                }
            }
            ret = GetResult(true, data);
            context.Response.Write(ret);
            context.Response.End();
        }


        /// <summary>
        /// 保存练习考试
        /// </summary>
        /// <param name="context"></param>
        public void SaveTheoryExam_Lianxi(HttpContext context)
        {

            var data = context.Request.Params["data"];
            var ret = string.Empty;
            if (string.IsNullOrEmpty(data))
            {
                ret = GetResult(false, "data参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            string result_id = context.Request.Params["result_id"];
            if (string.IsNullOrEmpty(result_id))
            {
                ret = GetResult(false, "result_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            var exist = bll_batch_result.GetModel(result_id);
            if (null!= exist)
            {
                ret = GetResult(false, "result_id:"+ result_id+"，考试记录已经存在");
                context.Response.Write(ret);
                context.Response.End();
            }

            //参数  data:  {"user_id":"USER202311160932356769","batch_id":"1716253531736","list_item_answer":"[]"}
            theory_result_request result_item = null;
            try
            {
                result_item = JsonConvert.DeserializeObject<theory_result_request>(data);
            }
            catch (Exception ex)
            {
                ret = GetResult(false, "参数data 异常：" + ex.Message);
                context.Response.Write(ret);
                context.Response.End();
            }

            var user = bll_user.GetModel(result_item.user_id);
            if (null == user)
            {
                ret = GetResult(false, "用户不存在， user_id：" + result_item.user_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var batch = bll_lianxi_batch.GetModel(result_item.batch_id);
            if (null == batch)
            {
                ret = GetResult(false, "考试场次不存在 ，batch_id：" + result_item.batch_id);
                context.Response.Write(ret);
                context.Response.End();
            }

            var exam = bll_examination.GetModel(batch.exam_id);
            if (null == exam)
            {
                ret = GetResult(false, "试卷不存在 ，batch_id：" + result_item.batch_id + ", exam_id：" + batch.exam_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            /*
            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", result_item.batch_id, result_item.user_id);
            var exist_list = bll_batch_result.GetModelList(qry);
            if (exist_list.Count > 0)
            {
                ret = GetResult(false, "成绩已经提交");
                context.Response.Write(ret);
                context.Response.End();
            }
            */
            var list_answer_user = result_item.list_item_answer;
            var count = SaveResultScore_LianXi(result_id,user, batch, list_answer_user, out DataService.Model.pro_exam_batch_result result);
            if (count > 0)
            {
                ret = GetResult(true, result, "");
                context.Response.Write(ret);
                context.Response.End();
            }
            else
            {
                ret = GetResult(false, "保存数据失败");
                context.Response.Write(ret);
                context.Response.End();
            }
        }

        /// <summary>
        /// 保存理论考核
        /// </summary>
        /// <param name="context"></param>
        public void SaveTheoryExam(HttpContext context)
        {
            /*
            theory_result_request obj = new theory_result_request();
            obj.user_id = "USER202311160932356769";
            obj.batch_id = "1716253531736";

            var list_item_answer_user = new List<theory_item_answer>();
            var item = new theory_item_answer();
            item.theory_base_id = "1715825424604";
            item.your_answer = "A";
            list_item_answer_user.Add(item);

            item = new theory_item_answer();
            item.theory_base_id = "1715411027974";
            item.your_answer = "A";
            list_item_answer_user.Add(item);

            item = new theory_item_answer();
            item.theory_base_id = "5438";
            item.your_answer = "A,D";
            list_item_answer_user.Add(item);

            item = new theory_item_answer();
            item.theory_base_id = "1715760455104";
            item.your_answer = "A,D";
            list_item_answer_user.Add(item);

            obj.list_item_answer = list_item_answer_user;
            var json = JsonConvert.SerializeObject(obj);

            */

            var data = context.Request.Params["data"];
            var ret = string.Empty;
            if (string.IsNullOrEmpty(data))
            {
                ret = GetResult(false, "data参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            //参数  data:  {"user_id":"USER202311160932356769","batch_id":"1716253531736","list_item_answer":"[]"}
            theory_result_request result_item = null;
            try
            {
                result_item = JsonConvert.DeserializeObject<theory_result_request>(data);
            }
            catch (Exception ex)
            {
                ret = GetResult(false, "参数data 异常：" + ex.Message);
                context.Response.Write(ret);
                context.Response.End();
            }

            var user = bll_user.GetModel(result_item.user_id);
            if (null == user)
            {
                ret = GetResult(false, "用户不存在， user_id：" + result_item.user_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var batch = bll_exam_batch.GetModel(result_item.batch_id);
            if (null == batch)
            {
                ret = GetResult(false, "考试场次不存在 ，batch_id：" + result_item.batch_id);
                context.Response.Write(ret);
                context.Response.End();
            }

            var exam = bll_examination.GetModel(batch.exam_id);
            if (null == exam)
            {
                ret = GetResult(false, "试卷不存在 ，batch_id：" + result_item.batch_id + ", exam_id：" + batch.exam_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", result_item.batch_id, result_item.user_id);
            var exist_list = bll_batch_result.GetModelList(qry);
            if (exist_list.Count > 0)
            {
                ret = GetResult(false, "成绩已经提交");
                context.Response.Write(ret);
                context.Response.End();
            }
            var list_answer_user = result_item.list_item_answer;
            var count = SaveResultScore(user, batch, list_answer_user);
            if (count > 0)
            {
                ret = GetResult(true);
                context.Response.Write(ret);
                context.Response.End();
            }
        }


        /// <summary>
        /// 保存理论考核缓存
        /// </summary>
        /// <param name="context"></param>
        public void SaveTheoryCache(HttpContext context)
        {

            var data = context.Request.Params["data"];
            var ret = string.Empty;
            if (string.IsNullOrEmpty(data))
            {
                ret = GetResult(false, "data参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            //参数  data:  {"user_id":"USER202311160932356769","batch_id":"1716253531736","list_item_answer":"[]"}
            theory_result_request result_item = null;
            try
            {
                result_item = JsonConvert.DeserializeObject<theory_result_request>(data);
            }
            catch (Exception ex)
            {
                ret = GetResult(false, "参数data 异常：" + ex.Message);
                context.Response.Write(ret);
                context.Response.End();
            }

            var user = bll_user.GetModel(result_item.user_id);
            if (null == user)
            {
                ret = GetResult(false, "用户不存在， user_id：" + result_item.user_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var batch = bll_exam_batch.GetModel(result_item.batch_id);
            if (null == batch)
            {
                ret = GetResult(false, "考试场次不存在 ，batch_id：" + result_item.batch_id);
                context.Response.Write(ret);
                context.Response.End();
            }

            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", result_item.batch_id, result_item.user_id);
            var exist_list = bll_base_cache.GetModelList(qry).OrderByDescending(s => s.start_time).ToList();
            if (exist_list.Count <= 0)
            {
                var new_cache = new DataService.Model.pro_theory_base_cache();
                var id = BasePage.GetId();
                new_cache.id = id;
                new_cache.start_time = DateTime.Now;
                new_cache.user_id = result_item.user_id;
                new_cache.batch_id = result_item.batch_id;
                int index = 1;
                List<DataService.Model.pro_theory_base_cache_item> list_cache_items = new List<DataService.Model.pro_theory_base_cache_item>();
                foreach (var item in result_item.list_item_answer)
                {
                    var cache_item = new DataService.Model.pro_theory_base_cache_item();
                    cache_item.id = BasePage.GetNextId(id, index++);
                    cache_item.cache_id = id;
                    cache_item.theory_base_id = item.theory_base_id;
                    cache_item.your_answer = item.your_answer;
                    list_cache_items.Add(cache_item);
                }
                //添加缓存及添加缓存项
                var count = bll_base_cache.BatchAddCache(new_cache, list_cache_items);
                if (count > 0)
                {
                    ret = GetResult(true);
                    context.Response.Write(ret);
                    context.Response.End();
                }

            }
            else
            {
                var update_cache = exist_list[0];
                var update_id = update_cache.id;
                int index = 1;
                List<DataService.Model.pro_theory_base_cache_item> list_cache_items = new List<DataService.Model.pro_theory_base_cache_item>();
                if (result_item.list_item_answer.Count <= 0)
                {
                    ret = GetResult(true);
                    context.Response.Write(ret);
                    context.Response.End();
                }
                else
                {
                    foreach (var item in result_item.list_item_answer)
                    {
                        var cache_item = new DataService.Model.pro_theory_base_cache_item();
                        cache_item.id = BasePage.GetNextId(update_id, index++);
                        cache_item.cache_id = update_id;
                        cache_item.theory_base_id = item.theory_base_id;
                        cache_item.your_answer = item.your_answer;
                        list_cache_items.Add(cache_item);
                    }
                    //删除缓存项及添加缓存项
                    var count = bll_base_cache.BatchDeleteItemAddItem(update_id, list_cache_items);
                    if (count > 0)
                    {
                        ret = GetResult(true);
                        context.Response.Write(ret);
                        context.Response.End();
                    }
                }

            }

            /*
            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", result_item.batch_id, result_item.user_id);
            var exist_list = bll_base_cache.GetModelList(qry);
            var new_cache = new DataService.Model.pro_theory_base_cache();
            var id = BasePage.GetId();
            new_cache.id = id;
            new_cache.start_time = DateTime.Now;
            new_cache.user_id = result_item.user_id;
            new_cache.batch_id = result_item.batch_id;
            int index = 1;
            List<DataService.Model.pro_theory_base_cache_item> list_cache_items = new List<DataService.Model.pro_theory_base_cache_item>();
            foreach (var item in result_item.list_item_answer)
            {
                var cache_item = new DataService.Model.pro_theory_base_cache_item();
                cache_item.id = BasePage.GetNextId(id, index++);
                cache_item.cache_id = id;
                cache_item.theory_base_id = item.theory_base_id;
                cache_item.your_answer = item.your_answer;
                list_cache_items.Add(cache_item);
            }
            var count = bll_base_cache.BatchDeleteAddCache(exist_list, new_cache, list_cache_items);

            if (count > 0)
            {
                ret = GetResult(true);
                context.Response.Write(ret);
                context.Response.End();
            }
            */
        }

        /// <summary>
        /// 保存理论考核缓存
        /// </summary>
        /// <param name="context"></param>
        public void GetTheoryCache(HttpContext context)
        {
            var ret = string.Empty;
            var user_id = context.Request.Params["user_id"];

            if (string.IsNullOrEmpty(user_id))
            {
                ret = GetResult(false, "user_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }

            var batch_id = context.Request.Params["batch_id"];

            if (string.IsNullOrEmpty(batch_id))
            {
                ret = GetResult(false, "batch_id参数不能为空");
                context.Response.Write(ret);
                context.Response.End();
            }
            /*
            var user = bll_user.GetModel(result_item.user_id);
            if (null == user)
            {
                ret = GetResult(false, "用户不存在， user_id：" + result_item.user_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            var batch = bll_exam_batch.GetModel(result_item.batch_id);
            if (null == batch)
            {
                ret = GetResult(false, "考试场次不存在 ，batch_id：" + result_item.batch_id);
                context.Response.Write(ret);
                context.Response.End();
            }
            */

            var qry = string.Format("batch_id='{0}' and user_id='{1}' ", batch_id, user_id);
            var model = bll_base_cache.GetModelList(qry).OrderByDescending(s => s.start_time).FirstOrDefault();
            if (null == model)
            {
                ret = GetResult(false, "缓存不存在！");
                context.Response.Write(ret);
                context.Response.End();
            }

            var list = bll_base_cache_item.GetModelList("cache_id='" + model.id + "'");
            theory_result_request back = new theory_result_request();
            back.user_id = user_id;
            back.batch_id = batch_id;
            back.list_item_answer = new List<theory_item_answer>();
            foreach (var item in list)
            {
                var answer = new theory_item_answer();
                answer.theory_base_id = item.theory_base_id;
                answer.your_answer = item.your_answer;
                back.list_item_answer.Add(answer);
            }
            ret = GetResult(true, back);
            context.Response.Write(ret);
            context.Response.End();
        }

        /// <summary>
        /// 保存练习考试并判分
        /// </summary>
        /// <param name="user"></param>
        /// <param name="batch"></param>
        /// <param name="list_answer_user"></param>
        /// <returns></returns>
        public int SaveResultScore_LianXi(string result_id_ ,DataService.Model.admin_user user, DataService.Model.pro_lianxi_batch batch, List<theory_item_answer> list_answer_user, out DataService.Model.pro_exam_batch_result result)
        {
            var exam = bll_examination.GetModel(batch.exam_id);

            List<theory_item_answer> list_item_answer_user = list_answer_user;
            if (null == list_item_answer_user)
            {
                list_item_answer_user = new List<theory_item_answer>();

                #region 假数据
                /* 
                var item = new theory_item_answer();
                item.theory_base_id = "1715825424604";
                item.your_answer = "A";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "1715411027974";
                item.your_answer = "A";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "5438";
                item.your_answer = "A,D";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "1715760455104";
                item.your_answer = "A,D";
                list_item_answer_user.Add(item);
                */

                #endregion

            }
            var list_theory_item_score_stand = bll_pro_exam_theory.QueryTheoryBaseScore(batch.exam_id);
            var result_insert = new DataService.Model.pro_exam_batch_result();
            var list_details_Insert = new List<DataService.Model.pro_exam_batch_result_detail>();
            var now = DateTime.Now;

            var result_id = result_id_;
            result_insert.result_id = result_id;

            result_insert.batch_id = batch.batch_id;
            //result_insert.batch_name = batch.batch_name;
            result_insert.batch_name = batch.subject;
            result_insert.r1 = "1";

            result_insert.exam_id = exam.id;
            result_insert.exam_name = exam.exam_name;
            result_insert.pass_score = exam.pass_score;

            result_insert.user_id = user.user_id;
            result_insert.login_name = user.login_name;
            result_insert.real_name = user.real_name;
            result_insert.grade = user.grade;
            result_insert.school_id = user.school_id;
            var school = bll_school.GetModel(user.school_id);
            if (null != school)
            {
                result_insert.school = school.school;
            }

            result_insert.examine_time = now;
            result_insert.create_time = now;
            result_insert.total = decimal.Parse(exam.total_score);

            int index = 1;
            decimal total_score = 0;
            for (int i = 0; i < list_theory_item_score_stand.Count; i++)
            {
                var stand = list_theory_item_score_stand[i];
                var model = new DataService.Model.pro_exam_batch_result_detail();
                model.id = BasePage.GetNextId(result_id, index++);
                model.create_time = now;
                model.result_id = result_id;
                model.theory_base_id = stand.theory_base_id;
                model.no = stand.no;
                model.question = stand.question;
                model.kind = stand.kind;
                model.question_difficult = stand.question_difficult;

                model.right_answer = stand.answer;
                model.total = stand.per_score;
                model.score = 0;
                model.is_right = 0; // 正确 1：是  ， 0 ：否
                model.your_answer = "";

                var user_answer = list_item_answer_user.FirstOrDefault(s => s.theory_base_id == stand.theory_base_id);
                if (null != user_answer)
                {
                    model.your_answer = user_answer.your_answer;
                    if (model.kind == "多选题")
                    {

                        //逻辑是
                        //选项=答案  得满分
                        //选项 in 答案  得半分
                        //选项 not in 答案  不得分
                        //选项为空  不得分

                        var stand_full = "";
                        var your_full = "";

                        var stand_array = stand.answer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        if (stand_array.Length >= 2)
                        {
                            stand_array = stand_array.OrderBy(s => s).ToArray();
                            stand_full = string.Join(",", stand_array);
                        }
                        else if (stand_array.Length == 1)
                        {
                            stand_full = stand_array[0];
                        }
                        var your_array = model.your_answer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        if (your_array.Length >= 2)
                        {
                            your_array = your_array.OrderBy(s => s).ToArray();
                            your_full = string.Join(",", your_array);
                        }
                        else if (your_array.Length == 1)
                        {
                            your_full = your_array[0];
                        }

                        if (string.IsNullOrWhiteSpace(user_answer.your_answer)) //选项为空  不得分
                        {
                            ;
                        }
                        //else if (user_answer.your_answer == stand.answer) //选项=答案  得满分
                        else if (stand_full == your_full) //选项=答案  得满分
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                        else
                        {
                            var all_in = true;
                            foreach (var your in your_array)
                            {
                                if (!stand_array.Contains(your))
                                {
                                    all_in = false;
                                    break;
                                }
                            }
                            if (all_in)
                            {
                                model.is_right = 2; //缺
                                //decimal half_score = stand.per_score / 2;
                                decimal half_score = Math.Floor((stand.per_score / 2) * 1000) / 1000;
                                model.score = half_score;
                                total_score += half_score;
                            }
                        }
                    }
                    #region  填空题
                    else if (model.kind == "填空题")
                    {
                        if (user_answer.your_answer == stand.answer)
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                        else
                        {
                            var array_user = user_answer.your_answer.Split(new string[] { "__" }, StringSplitOptions.None);
                            var array_answer = stand.answer.Split(new string[] { "__" }, StringSplitOptions.None);
                            // 或者使用 Truncate 方法
                            //decimal resultTruncateAlt = decimal.Truncate((num1 / num2) * 1000) / 1000;
                            decimal tiankong_total = stand.per_score;
                            decimal user_score = 0;
                            if (array_user.Length == array_answer.Length)
                            {
                                // 舍去多余的小数位
                                decimal resultTruncate = Math.Floor((tiankong_total / array_user.Length) * 1000) / 1000;
                                for (int item_index = 0; item_index < array_user.Length; item_index++)
                                {
                                    if (array_user[item_index] == array_answer[item_index])
                                    {
                                        user_score += resultTruncate;
                                    }
                                }
                                if (user_score > 0)
                                {
                                    model.is_right = 2;
                                }
                                model.score = user_score;
                                total_score += user_score;
                            }
                        }
                    }
                    else if (model.kind == "简答题")
                    {
                        ;
                    }
                    #endregion
                    else
                    {
                        if (user_answer.your_answer == stand.answer)
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                    }
                }
                list_details_Insert.Add(model);
            }
            //赋值总得分
            result_insert.score = total_score;

            result = result_insert;
            return bll_batch_result.BatchAdd_ResultDetails(list_details_Insert, result_insert);
        }

        /// <summary>
        /// 保存理论考试并判分
        /// </summary>
        /// <param name="user"></param>
        /// <param name="batch"></param>
        /// <param name="list_answer_user"></param>
        /// <returns></returns>
        public int SaveResultScore(DataService.Model.admin_user user, DataService.Model.pro_exam_batch batch, List<theory_item_answer> list_answer_user)
        {
            var exam = bll_examination.GetModel(batch.exam_id);

            List<theory_item_answer> list_item_answer_user = list_answer_user;
            if (null == list_item_answer_user)
            {
                list_item_answer_user = new List<theory_item_answer>();

                #region 假数据
                /* 
                var item = new theory_item_answer();
                item.theory_base_id = "1715825424604";
                item.your_answer = "A";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "1715411027974";
                item.your_answer = "A";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "5438";
                item.your_answer = "A,D";
                list_item_answer_user.Add(item);

                item = new theory_item_answer();
                item.theory_base_id = "1715760455104";
                item.your_answer = "A,D";
                list_item_answer_user.Add(item);
                */

                #endregion

            }
            var list_theory_item_score_stand = bll_pro_exam_theory.QueryTheoryBaseScore(batch.exam_id);
            var result_insert = new DataService.Model.pro_exam_batch_result();
            var list_details_Insert = new List<DataService.Model.pro_exam_batch_result_detail>();
            var now = DateTime.Now;

            var result_id = BasePage.GetId();
            result_insert.result_id = result_id;

            result_insert.batch_id = batch.batch_id;
            result_insert.batch_name = batch.batch_name;

            result_insert.exam_id = exam.id;
            result_insert.exam_name = exam.exam_name;

            result_insert.user_id = user.user_id;
            result_insert.login_name = user.login_name;
            result_insert.real_name = user.real_name;
            result_insert.grade = user.grade;
            result_insert.school_id = user.school_id;
            var school = bll_school.GetModel(user.school_id);
            if (null != school)
            {
                result_insert.school = school.school;
            }

            result_insert.examine_time = now;
            result_insert.create_time = now;
            result_insert.total = decimal.Parse(exam.total_score);

            int index = 1;
            decimal total_score = 0;
            for (int i = 0; i < list_theory_item_score_stand.Count; i++)
            {
                var stand = list_theory_item_score_stand[i];
                var model = new DataService.Model.pro_exam_batch_result_detail();
                model.id = BasePage.GetNextId(result_id, index++);
                model.create_time = now;
                model.result_id = result_id;
                model.theory_base_id = stand.theory_base_id;
                model.no = stand.no;
                model.question = stand.question;
                model.kind = stand.kind;
                model.question_difficult = stand.question_difficult;

                model.right_answer = stand.answer;
                model.total = stand.per_score;
                model.score = 0;
                model.is_right = 0; // 正确 1：是  ， 0 ：否
                model.your_answer = "";

                var user_answer = list_item_answer_user.FirstOrDefault(s => s.theory_base_id == stand.theory_base_id);
                if (null != user_answer)
                {
                    model.your_answer = user_answer.your_answer;
                    if (model.kind == "多选题")
                    {

                        //逻辑是
                        //选项=答案  得满分
                        //选项 in 答案  得半分
                        //选项 not in 答案  不得分
                        //选项为空  不得分

                        var stand_full = "";
                        var your_full = "";

                        var stand_array = stand.answer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        if (stand_array.Length >= 2)
                        {
                            stand_array = stand_array.OrderBy(s => s).ToArray();
                            stand_full = string.Join(",", stand_array);
                        }
                        else if (stand_array.Length == 1)
                        {
                            stand_full = stand_array[0];
                        }
                        var your_array = model.your_answer.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                        if (your_array.Length >= 2)
                        {
                            your_array = your_array.OrderBy(s => s).ToArray();
                            your_full = string.Join(",", your_array);
                        }
                        else if (your_array.Length == 1)
                        {
                            your_full = your_array[0];
                        }

                        if (string.IsNullOrWhiteSpace(user_answer.your_answer)) //选项为空  不得分
                        {
                            ;
                        }
                        //else if (user_answer.your_answer == stand.answer) //选项=答案  得满分
                        else if (stand_full == your_full) //选项=答案  得满分
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                        else
                        {
                            var all_in = true;
                            foreach (var your in your_array)
                            {
                                if (!stand_array.Contains(your))
                                {
                                    all_in = false;
                                    break;
                                }
                            }
                            if (all_in)
                            {
                                model.is_right = 2; //缺
                                //decimal half_score = stand.per_score / 2;
                                decimal half_score = Math.Floor((stand.per_score / 2) * 1000) / 1000;
                                model.score = half_score;
                                total_score += half_score;
                            }
                        }
                    }
                    #region  填空题
                    else if (model.kind == "填空题")
                    {
                        if (user_answer.your_answer == stand.answer)
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                        else
                        {
                            var array_user = user_answer.your_answer.Split(new string[] { "__" }, StringSplitOptions.None);
                            var array_answer = stand.answer.Split(new string[] { "__" }, StringSplitOptions.None);
                            // 或者使用 Truncate 方法
                            //decimal resultTruncateAlt = decimal.Truncate((num1 / num2) * 1000) / 1000;
                            decimal tiankong_total = stand.per_score;
                            decimal user_score = 0;
                            if (array_user.Length == array_answer.Length)
                            {
                                // 舍去多余的小数位
                                decimal resultTruncate = Math.Floor((tiankong_total / array_user.Length) * 1000) / 1000;
                                for (int item_index = 0; item_index < array_user.Length; item_index++)
                                {
                                    if (array_user[item_index] == array_answer[item_index])
                                    {
                                        user_score += resultTruncate;
                                    }
                                }
                                if (user_score > 0)
                                {
                                    model.is_right = 2;
                                }
                                model.score = user_score;
                                total_score += user_score;
                            }
                        }
                    }
                    else if (model.kind == "简答题")
                    {
                        ;
                    }
                    #endregion
                    else
                    {
                        if (user_answer.your_answer == stand.answer)
                        {
                            model.is_right = 1;
                            model.score = stand.per_score;
                            total_score += stand.per_score;
                        }
                    }
                }
                list_details_Insert.Add(model);
            }
            //赋值总得分
            result_insert.score = total_score;



            return bll_batch_result.BatchAdd_ResultDetails(list_details_Insert, result_insert);
        }

        /// <summary>
        /// 保存理论考核缓存
        /// </summary>
        /// <param name="context"></param>
        public void GetServerTime(HttpContext context)
        {
            var ret = string.Empty;
            var time = bll_exam_batch.GetServerTime();
            ret = GetResult(true, time.ToString("yyyy-MM-dd HH:mm:ss"), "");
            context.Response.Write(ret);
            context.Response.End();
        }

        public void GetId(HttpContext context)
        {
            var id = BasePage.GetId();
            var ret = GetResult(true, id, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
            context.Response.Write(ret);
            context.Response.End();
        }

        /// <summary>
        /// 理论考试成绩提交实体
        /// </summary>
        public class theory_result_request
        {

            /// <summary>
            /// 用户id
            /// </summary>
            public string user_id { get; set; }

            /// <summary>
            /// 批次id
            /// </summary>
            public string batch_id { get; set; }

            /// <summary>
            /// 
            /// </summary>
            public List<theory_item_answer> list_item_answer { get; set; }

        }

        public class theory_item_answer
        {
            /// <summary>
            /// 题目id
            /// </summary>
            public string theory_base_id { get; set; }

            /// <summary>
            /// 批次id
            /// </summary>
            public string your_answer { get; set; }
        }

        /*
      public  class  batch_result_request
      {
          public string user_id { get; set; }

          public string batch_id { get; set; }

          public decimal total { get; set; }

          public decimal score { get; set; }
      }
      */




        public class theory_base_item_response
        {

            /// <summary>
            /// 题干
            /// </summary>


            /// <summary>
            /// 顺序编号
            /// </summary>
            public int no { get; set; }

            /// <summary>
            /// 选项字母
            /// </summary>
            public string item_letter { get; set; }

            /// <summary>
            /// 选项名称
            /// </summary>
            public string item { get; set; }
        }


        public class theory_base_response
        {
            /// <summary>
            /// 题目id
            /// </summary>
            public string theory_base_id { get; set; }

            #region   new added
            public string question { get; set; }
            public string answer { get; set; }
            #endregion

            /// <summary>
            /// 题目类型
            /// </summary>
            public string question_kind { get; set; }
            /// <summary>
            /// 顺序编号
            /// </summary>
            public int no { get; set; }

            /// <summary>
            /// 题目分数
            /// </summary>
            public decimal per_score { get; set; }



        }

        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }
}