package servicer

import (
	"time"
	"zhiyuan/pkg/app"
	orderParam "zhiyuan/pkg/param/order"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"
	"zhiyuan/services/aftersale"
	"zhiyuan/services/aftersale/order"
	"zhiyuan/services/form"
	"zhiyuan/services/material/brand"
	"zhiyuan/services/region"

	"github.com/gin-gonic/gin"
)

func OrderList(c *gin.Context) {
	page := app.HandlePageNum(c)
	where := map[string]string{
		"where":     " o.deleted_at=0",
		"_group_by": "o.id",
		"_order_by": "o.id desc",
	}
	param := make(map[string]interface{})
	param["admin_id"] = c.GetInt("adminID")
	//where := map[string]interface{}{"deleted_at": 0, "_orderby": "id desc"}
	states := make([]int, 0)
	tabIndex := utils.ToInt(c.Query("tab_index"))
	id := utils.ToInt(c.Query("id"))
	if id > 0 {
		where["where"] = where["where"] + " AND o.id = {{id}}"
		param["id"] = id
		//where["id"] = id
	}
	switch tabIndex {
	case 0:
		states = append(states, orderParam.State.Created.ID)
	case 1:
		states = append(states,
			orderParam.State.Checked.ID,
			orderParam.State.Suspending.ID,
		)
	case 2:
		states = append(states,
			orderParam.State.Allotted.ID,
			orderParam.State.SupConfirmed.ID,
			orderParam.State.Repairing.ID,
			orderParam.State.Repaired.ID,
			orderParam.State.Confirmed.ID,
		)
	case 3:
		states = append(states,
			orderParam.State.Completed.ID,
			orderParam.State.ForceCompleted.ID,
		)
	}
	if tabIndex >= 0 {
		where["where"] = where["where"] + " AND if(o.state=90,90,if(o.is_force=0,o.state,100)) in {{states}}"
		param["states"] = states
		//where["if(state=90,90,if(is_force=0,state,100)) in"] = states
	}

	// site_id
	if adminInfo := admin.GetAdminCache(c.GetInt("adminID")); adminInfo.SiteID > 0 {
		where["where"] = where["where"] + " AND o.site_id = {{site_id}}"
		param["site_id"] = adminInfo.SiteID
		//where["site_id"] = adminInfo.SiteID
	}
	dayDate := utils.GetZeroTime(time.Now()).Unix()
	listType := utils.ToInt(c.Query("list_type"))
	if listType == 1 {
		where["where"] = where["where"] + " AND (o.created_at between {{mindate}} and {{maxdate}})"
		param["mindate"] = dayDate
		param["maxdate"] = dayDate + 86399
		//where["created_at between"] = []interface{}{dayDate, dayDate + 86399}
	} else if listType == 2 {
		where["where"] = where["where"] + " AND (v.visit_time between {{mindate}} and {{maxdate}}) AND v.state=1"
		param["mindate"] = dayDate
		param["maxdate"] = dayDate + 86399
		//where["recent_visit_time between"] = []interface{}{dayDate, dayDate + 86399}
	}
	leaderID := utils.ToInt(c.Query("leader_id"))
	if leaderID > 0 {
		where["where"] = where["where"] + " AND o.leader = {{leader}}"
		param["leader"] = leaderID
		//where["leader"] = leaderID
	}

	keyword := c.Query("keyword")
	if keyword != "" {
		where["where"] = where["where"] + " AND (o.link_name like {{keyword}} or o.link_phone like {{keyword}})"
		param["keyword"] = "%" + keyword + "%"
		/*where["_or"] = []map[string]interface{}{
			{"link_name like": "%" + keyword + "%"},
			{"link_phone like": "%" + keyword + "%"},
		}*/
	}
	type Auth struct {
		Check    bool `json:"check"`
		Allot    bool `json:"allot"`
		ReAllot  bool `json:"re_allot"`
		Delete   bool `json:"delete"`
		Suspend  bool `json:"suspend"`
		Complete bool `json:"complete"`
	}
	type Admin struct {
		ID       int    `json:"id"`
		UserName string `json:"username"`
		Phone    string `json:"phone"`
	}
	type OrderList struct {
		ID              int      `json:"id"`
		OrderNo         string   `json:"order_no"`
		MainType        int      `json:"main_type"`
		SubType         int      `json:"sub_type"`
		Type            string   `json:"type"`
		LinkName        string   `json:"link_name"`
		LinkPhone       string   `json:"link_phone"`
		Address         string   `json:"address"`
		Content         string   `json:"content"`
		Pics            []string `json:"pics"`
		RepairID        int      `json:"repair_id"`
		State           int      `json:"state"`
		StateName       string   `json:"state_name"`
		StateColor      string   `json:"state_color"`
		IsIssue         int      `json:"is_issue"`
		Auth            Auth     `json:"auth"`
		CreatedAt       string   `json:"created_at"`
		Leader          int      `json:"leader"`
		LeaderInfo      *Admin   `json:"leader_info"`
		RecentVisitTime string   `json:"recent_visit_time"`
		WarrantyStart   string   `json:"warranty_start"`
		WarrantyEnd     string   `json:"warranty_end"`
		WarrantyPeriod  string   `json:"warranty_period"`
		IsForce         int      `json:"is_force"`
	}
	orderList := make([]OrderList, 0)
	//_, err := order.GetList(where, nil, page, &orderList)
	err := order.GetListWidthVisit(where, param, page, &orderList)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	orderIds := make([]int, 0)
	for _, v := range orderList {
		orderIds = append(orderIds, v.ID)
	}
	adminIds := make([]int, 0)
	for _, v := range orderList {
		orderIds = append(orderIds, v.ID)
		if v.Leader > 0 {
			adminIds = append(adminIds, v.Leader)
		}
	}

	// 订单详细信息
	type OrderDetailList struct {
		OrderID  int    `json:"order_id"`
		Province int    `json:"province"`
		City     int    `json:"city"`
		Region   int    `json:"region"`
		Address  string `json:"address"`
		Content  string `json:"content"`
		Pics     string `json:"pics"`
	}
	orderDetailList := make([]OrderDetailList, 0)
	detailMap := make(map[int]OrderDetailList, 0)
	regionCodes := make([]int, 0)
	if len(orderIds) > 0 {
		_, err = order.GetDetailList(map[string]interface{}{"order_id in ": orderIds}, nil, app.Page{}, &orderDetailList)
		for _, v := range orderDetailList {
			detailMap[v.OrderID] = v
			regionCodes = append(regionCodes, v.Region, v.City, v.Province)
		}
	}
	regionMap, err := region.GetNameByCodes(regionCodes)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	orderTypeMap := aftersale.GetTypeMapByCache()
	orderStatusList := utils.ParseSliceMap(orderParam.Params.State, "id")
	adminMap := make(map[int]*Admin, 0)
	if len(adminIds) > 0 {
		adminList := make([]*Admin, 0)
		if _, err := admin.GetAdmins(map[string]interface{}{"id in": adminIds}, []string{"id, username, phone"}, app.Page{}, &adminList); err == nil {
			for _, v := range adminList {
				adminMap[v.ID] = v
			}
		}
	}
	for k, v := range orderList {
		if detail, ok := detailMap[v.ID]; ok {
			v.Content = detail.Content
			v.Pics = utils.ParseImgStr(detail.Pics)
			v.Address = region.GetFullAddressByCodes(detail.Province, detail.City, detail.Region, detail.Address, "", regionMap)
		}
		if v.State != orderParam.State.Completed.ID && v.IsForce != 0 {
			v.State = orderParam.State.ForceCompleted.ID
		}
		v.StateName = utils.ToStr(orderStatusList[utils.ToStr(v.State)]["name"])
		v.StateColor = utils.ToStr(orderStatusList[utils.ToStr(v.State)]["color"])
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD")
		v.Type = orderTypeMap[v.MainType] + "/" + orderTypeMap[v.SubType]
		v.Auth = Auth{
			Check:    utils.IsContain(orderParam.Allow.Check, v.State),
			Allot:    utils.IsContain(orderParam.Allow.Allot, v.State),
			ReAllot:  v.State != orderParam.State.Suspending.ID && utils.IsContain(orderParam.Allow.ReAllot, v.State),
			Delete:   utils.IsContain(orderParam.Allow.Delete, v.State),
			Suspend:  utils.IsContain(orderParam.Allow.Suspend, v.State),
			Complete: utils.IsContain(orderParam.Allow.Complete, v.State),
		}
		if v.Leader > 0 && adminMap[v.Leader] != nil {
			v.LeaderInfo = adminMap[v.Leader]
		} else {
			v.LeaderInfo = &Admin{}
		}
		if v.WarrantyStart != "0" {
			v.WarrantyPeriod = utils.DateS(v.WarrantyStart, "YYYY-MM-DD") + " 至 " + utils.DateS(v.WarrantyEnd, "YYYY-MM-DD")
		} else {
			v.WarrantyPeriod = "保修期外"
		}
		v.RecentVisitTime = utils.DateS(v.RecentVisitTime, "YYYY-MM-DD")
		orderList[k] = v
	}
	app.Success(c, orderList)
}

func OrderCheck(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}

	var form form.OrderCheck
	if app.Bind(c, &form) != nil {
		return
	}
	form.Servicer = c.GetInt("adminID")
	err := order.Check(form, id)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderComplete(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}
	var form form.OrderComplete
	if app.Bind(c, &form) != nil {
		return
	}
	form.Servicer = c.GetInt("adminID")
	err := order.Complete(form, id)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderAllot(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.ErrorMsg(c, "无效的订单ID", nil)
		return
	}
	var form form.OrderAllot
	if app.Bind(c, &form) != nil {
		return
	}
	form.Servicer = c.GetInt("adminID")
	if err := order.Allot(form, id); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func OrderSuspend(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.ErrorMsg(c, "无效的订单ID", nil)
		return
	}
	var form form.OrderSuspend
	if app.Bind(c, &form) != nil {
		return
	}
	form.Servicer = c.GetInt("adminID")
	if err := order.Suspend(form, id); err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func OrderVisitInfo(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "id 有误")
		return
	}
	type Visit struct {
		ID           int    `json:"id"`
		OrderID      int    `json:"order_id"`
		State        int    `json:"state"`
		Type1        int    `json:"type1"`
		Type2        int    `json:"type2"`
		Type3        int    `json:"type3"`
		Type4        int    `json:"type4"`
		ContactState int    `json:"contact_state"`
		StateName    string `json:"state_name"`
		VisitTime    string `json:"visit_time"`
		Content      string `json:"content"`
		FinishedAt   string `json:"finished_at"`
	}
	var visitInfo *Visit
	if _, err := order.GetVisit(map[string]interface{}{"id": id}, nil, &visitInfo); err != nil {
		app.Error(c, err.Error())
	}
	visitInfo.VisitTime = utils.DateS(visitInfo.VisitTime, "YYYY-MM-DD")
	visitInfo.FinishedAt = utils.DateS(visitInfo.FinishedAt, "YYYY-MM-DD")
	app.Success(c, visitInfo)
}

func OrderVisitAdd(c *gin.Context) {
	var form form.OrderVisitAdd
	if app.Bind(c, &form) != nil {
		return
	}
	if err := order.AddVisit(form); err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderVisitEdit(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}
	var form form.OrderVisitEdit
	if app.Bind(c, &form) != nil {
		return
	}
	if err := order.FinishVisit(form, id); err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderVisitDel(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}

	err := order.DelVisit(id)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderDel(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}

	err := order.Del(id)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

func OrderInfo(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}
	type Admin struct {
		ID       int    `json:"id"`
		UserName string `json:"username"`
		Phone    string `json:"phone"`
	}
	type OrderInfo struct {
		ID                int      `json:"id"`
		OrderNo           string   `json:"order_no"`
		MainType          int      `json:"main_type"`
		SubType           int      `json:"sub_type"`
		Type              string   `json:"type"`
		LinkName          string   `json:"link_name"`
		LinkPhone         string   `json:"link_phone"`
		Province          int      `json:"province"`
		City              int      `json:"city"`
		Region            int      `json:"region"`
		Address           string   `json:"address"`
		Content           string   `json:"content"`
		Pics              string   `json:"pics"`
		PicList           []string `json:"pic_list"`
		State             int      `json:"state"`
		StateName         string   `json:"state_name"`
		StateColor        string   `json:"state_color"`
		CreatedAt         string   `json:"created_at"`
		Leader            int      `json:"leader"`
		LeaderInfo        *Admin   `json:"leader_info"`
		RecentVisitTime   string   `json:"recent_visit_time"`
		WarrantyStart     string   `json:"warranty_start"`
		WarrantyEnd       string   `json:"warranty_end"`
		WarrantyPeriod    string   `json:"warranty_period"`
		MaintenanceRemark string   `json:"maintenance_remark"`
		StartTime         string   `json:"start_time"`
		EndTime           string   `json:"end_time"`
		FinishTime        string   `json:"finish_time"`
	}
	var orderInfo OrderInfo
	err := order.GetOneWithDetail("o.id={{id}}", map[string]interface{}{"id": id}, &orderInfo)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	adminIds := make([]int, 0)
	if orderInfo.Leader > 0 {
		adminIds = append(adminIds, orderInfo.Leader)
	}
	adminMap := make(map[int]*Admin, 0)
	if len(adminIds) > 0 {
		adminList := make([]*Admin, 0)
		if _, err := admin.GetAdmins(map[string]interface{}{"id in": adminIds}, []string{"id, username, phone"}, app.Page{}, &adminList); err == nil {
			for _, v := range adminList {
				adminMap[v.ID] = v
			}
		}
	}
	if orderInfo.Leader > 0 && adminMap[orderInfo.Leader] != nil {
		orderInfo.LeaderInfo = adminMap[orderInfo.Leader]
	} else {
		orderInfo.LeaderInfo = &Admin{}
	}
	orderTypeMap := aftersale.GetTypeMapByCache()
	orderStatusList := utils.ParseSliceMap(orderParam.Params.State, "id")
	orderInfo.PicList = utils.ParseImgStr(orderInfo.Pics)
	orderInfo.Address = region.GetFullAddressByCodes(orderInfo.Province, orderInfo.City, orderInfo.Region, orderInfo.Address, "", nil)
	orderInfo.StateName = utils.ToStr(orderStatusList[utils.ToStr(orderInfo.State)]["name"])
	orderInfo.StateColor = utils.ToStr(orderStatusList[utils.ToStr(orderInfo.State)]["color"])
	orderInfo.CreatedAt = utils.DateS(orderInfo.CreatedAt, "YYYY-MM-DD")
	orderInfo.Type = orderTypeMap[orderInfo.MainType] + "/" + orderTypeMap[orderInfo.SubType]
	orderInfo.RecentVisitTime = utils.DateS(orderInfo.RecentVisitTime, "YYYY-MM-DD")
	orderInfo.StartTime = utils.DateS(orderInfo.StartTime, "YYYY-MM-DD HH:mm")
	orderInfo.EndTime = utils.DateS(orderInfo.EndTime, "YYYY-MM-DD HH:mm")
	orderInfo.FinishTime = utils.DateS(orderInfo.FinishTime, "YYYY-MM-DD HH:mm")
	if orderInfo.WarrantyStart != "0" {
		orderInfo.WarrantyPeriod = utils.DateS(orderInfo.WarrantyStart, "YYYY-MM-DD") + " 至 " + utils.DateS(orderInfo.WarrantyEnd, "YYYY-MM-DD")
	} else {
		orderInfo.WarrantyPeriod = "保修期外"
	}

	// 订单事件
	type Event struct {
		Title     string   `json:"title"`
		Content   string   `json:"content"`
		Pics      string   `json:"pics"`
		PicList   []string `json:"pic_list"`
		CreatedAt string   `json:"created_at"`
	}
	eventList := make([]*Event, 0)
	if _, err = order.GetEventList(map[string]interface{}{"order_id": id, "_orderby": "created_at desc", "event_type": 1}, nil, &eventList); err != nil {
		app.Error(c, err.Error())
		return
	}
	for k, v := range eventList {
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD HH:mm")
		v.PicList = utils.ParseImgStr(v.Pics)
		eventList[k] = v
	}

	// 维修信息
	type Repair struct {
		ID           int      `json:"id"`
		WorkerName   string   `json:"worker_name"`
		WorkerPhone  string   `json:"worker_phone"`
		ScheduleTime string   `json:"schedule_time"`
		FinishedAt   string   `json:"finished_at"`
		Content      string   `json:"content"`
		Duration     float64  `json:"duration"`
		Pics         string   `json:"pics"`
		PicList      []string `json:"pic_list"`
		State        int      `json:"state"`
		StateName    string   `json:"state_name"`
		CreatedAt    string   `json:"created_at"`
		AuditType    int      `json:"audit_type"`
		AuditState   int      `json:"audit_state"`
		AuditAt      string   `json:"audit_at"`
		AuditRemark  string   `json:"audit_remark"`
	}
	repairList := make([]*Repair, 0)
	if _, err = order.GetRepairList(map[string]interface{}{"order_id": id, "_orderby": "created_at desc"}, nil, &repairList); err != nil {
		app.Error(c, err.Error())
		return
	}
	repairStatusList := utils.ParseSliceMap(orderParam.Params.RepairState, "id")
	for _, v := range repairList {
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD HH:mm")
		v.ScheduleTime = utils.DateS(v.ScheduleTime, "YYYY-MM-DD HH:mm")
		v.FinishedAt = utils.DateS(v.FinishedAt, "YYYY-MM-DD HH:mm")
		v.PicList = utils.ParseImgStr(v.Pics)
		v.StateName = utils.ToStr(repairStatusList[utils.ToStr(v.State)]["name"])
		v.AuditAt = utils.DateS(v.AuditAt, "YYYY-MM-DD HH:mm")
	}

	// 回访信息
	type Visit struct {
		ID         int    `json:"id"`
		OrderID    int    `json:"order_id"`
		State      int    `json:"state"`
		Type1      int    `json:"type1"`
		Type2      int    `json:"type2"`
		Type3      int    `json:"type3"`
		Type4      int    `json:"type4"`
		StateName  string `json:"state_name"`
		VisitTime  string `json:"visit_time"`
		Content    string `json:"content"`
		FinishedAt string `json:"finished_at"`
	}
	visitList := make([]*Visit, 0)
	if _, err := order.GetVisits(map[string]interface{}{"order_id": id, "_orderby": "created_at desc", "deleted_at": 0}, nil, &visitList); err != nil {
		app.Error(c, err.Error())
	}
	for _, v := range visitList {
		if v.State == 1 {
			v.StateName = "未完成"
		} else {
			v.StateName = "已完成"
		}
		v.VisitTime = utils.DateS(v.VisitTime, "YYYY-MM-DD")
		v.FinishedAt = utils.DateS(v.FinishedAt, "YYYY-MM-DD")
	}

	// 完结信息
	type Issue struct {
		ID           int    `json:"id"`
		Director     int    `json:"director"`
		DirectorName string `json:"director_name"`
		IssueID      int    `json:"issue_id"`
		IssueName    string `json:"issue_name"`
		IssueDesc    string `json:"issue_desc"`
		Brand        int    `json:"brand"`
		BrandName    string `json:"brand_name"`
		CreatedAt    string `json:"created_at"`
	}
	issueList := make([]*Issue, 0)
	if _, err := order.GetIssues(map[string]interface{}{"order_id": id, "_orderby": "created_at desc"}, nil, &issueList); err != nil {
		app.Error(c, err.Error())
	}
	issueMap := aftersale.GetIssueMapByCache()
	directorList := utils.ParseSliceMap(orderParam.Params.IssueDirector, "id")

	brandIds := make([]int, 0)
	for _, v := range issueList {
		brandIds = utils.AppendUniqueInt(brandIds, v.Brand)
	}
	brandMap := make(map[int]string)
	if len(brandIds) > 0 {
		if brandList, err := brand.GetList(map[string]interface{}{"id in": brandIds}, nil, app.Page{}, nil); err == nil {
			for _, v := range brandList {
				brandMap[v.ID] = v.BrandName
			}
		}
	}
	for _, v := range issueList {
		if issueName, ok := issueMap[v.IssueID]; ok {
			v.IssueName = issueName
		}
		v.DirectorName = utils.ToStr(directorList[utils.ToStr(v.Director)]["name"])
		if brandName, ok := brandMap[v.Brand]; ok {
			v.BrandName = brandName
		}
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD")
	}

	res := gin.H{
		"info":   orderInfo,
		"repair": repairList,
		"event":  eventList,
		"visit":  visitList,
		"issue":  issueList,
	}
	app.Success(c, res)
}

func RepairCheckList(c *gin.Context) {
	page := app.HandlePageNum(c)
	where := map[string]string{
		"where":     " o.deleted_at=0 and r.audit_type != 0",
		"_group_by": "r.id",
		"_order_by": "r.id desc",
	}
	param := make(map[string]interface{})

	auditState := utils.ToInt(c.Query("audit_state"))
	if auditState > 0 {
		where["where"] = where["where"] + " AND r.audit_state = {{auditState}}"
		param["auditState"] = auditState - 1
	}
	keyword := c.Query("keyword")
	if keyword != "" {
		where["where"] = where["where"] + " AND (o.link_name like {{keyword}} or o.link_phone like {{keyword}})"
		param["keyword"] = "%" + keyword + "%"
	}

	type Admin struct {
		ID       int    `json:"id"`
		UserName string `json:"username"`
		Phone    string `json:"phone"`
	}
	type RepairList struct {
		ID             int      `json:"id"`
		OrderId        int      `json:"order_id"`
		WorkerName     string   `json:"worker_name"`
		WorkerPhone    string   `json:"worker_phone"`
		ScheduleTime   string   `json:"schedule_time"`
		FinishedAt     string   `json:"finished_at"`
		Content        string   `json:"content"`
		Duration       float64  `json:"duration"`
		Pics           string   `json:"pics"`
		PicList        []string `json:"pic_list"`
		State          int      `json:"state"`
		StateName      string   `json:"state_name"`
		CreatedAt      string   `json:"created_at"`
		AuditType      int      `json:"audit_type"`
		AuditState     int      `json:"audit_state"`
		AuditAt        string   `json:"audit_at"`
		OrderNo        string   `json:"order_no"`
		MainType       int      `json:"main_type"`
		SubType        int      `json:"sub_type"`
		Type           string   `json:"type"`
		LinkName       string   `json:"link_name"`
		LinkPhone      string   `json:"link_phone"`
		Address        string   `json:"address"`
		DetailContent  string   `json:"detail_content"`
		DetailPics     string   `json:"detail_pics"`
		OrderCreatedAt string   `json:"order_created_at"`
		Leader         int      `json:"leader"`
		LeaderInfo     *Admin   `json:"leader_info"`
		WarrantyStart  string   `json:"warranty_start"`
		WarrantyEnd    string   `json:"warranty_end"`
		WarrantyPeriod string   `json:"warranty_period"`
		IsForce        int      `json:"is_force"`
		EndTime        string   `json:"end_time"`
	}
	repairList := make([]RepairList, 0)
	err := order.GetListWidthOrder(where, param, page, &repairList)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	adminIds := make([]int, 0)
	for _, v := range repairList {
		if v.Leader > 0 {
			adminIds = append(adminIds, v.Leader)
		}
	}
	orderTypeMap := aftersale.GetTypeMapByCache()
	adminMap := make(map[int]*Admin, 0)
	if len(adminIds) > 0 {
		adminList := make([]*Admin, 0)
		if _, err := admin.GetAdmins(map[string]interface{}{"id in": adminIds}, []string{"id, username, phone"}, app.Page{}, &adminList); err == nil {
			for _, v := range adminList {
				adminMap[v.ID] = v
			}
		}
	}
	repairStatusList := utils.ParseSliceMap(orderParam.Params.RepairState, "id")
	for k, v := range repairList {
		v.PicList = utils.ParseImgStr(v.Pics)
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD")
		v.Type = orderTypeMap[v.MainType] + "/" + orderTypeMap[v.SubType]
		if v.Leader > 0 && adminMap[v.Leader] != nil {
			v.LeaderInfo = adminMap[v.Leader]
		} else {
			v.LeaderInfo = &Admin{}
		}
		if v.WarrantyStart != "0" {
			v.WarrantyPeriod = utils.DateS(v.WarrantyStart, "YYYY-MM-DD") + " 至 " + utils.DateS(v.WarrantyEnd, "YYYY-MM-DD")
		} else {
			v.WarrantyPeriod = "保修期外"
		}
		v.ScheduleTime = utils.DateS(v.ScheduleTime, "YYYY-MM-DD")
		v.CreatedAt = utils.DateS(v.CreatedAt, "YYYY-MM-DD")
		v.OrderCreatedAt = utils.DateS(v.OrderCreatedAt, "YYYY-MM-DD")
		v.EndTime = utils.DateS(v.EndTime, "YYYY-MM-DD HH:mm")
		v.FinishedAt = utils.DateS(v.FinishedAt, "YYYY-MM-DD HH:mm")
		v.AuditAt = utils.DateS(v.AuditAt, "YYYY-MM-DD HH:mm")
		v.StateName = utils.ToStr(repairStatusList[utils.ToStr(v.State)]["name"])
		repairList[k] = v
	}
	app.Success(c, repairList)
}

func RepairCheck(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}

	var form form.RepairCheck
	if app.Bind(c, &form) != nil {
		return
	}
	err := order.RepairCheck(id, form.State, c.GetInt("adminID"), form.Remark)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

/*
*
延期工单，是否确认审核
*/
func ExtensionCheck(c *gin.Context) {
	id := utils.StrTo(c.Param("id")).MustInt()
	if id <= 0 {
		app.Error(c, "工单 id 有误")
		return
	}

	var form form.RepairCheck
	if app.Bind(c, &form) != nil {
		return
	}
	err := order.ExtensionCheck(id, form.State, c.GetInt("adminID"), form.Remark)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	app.Success(c, nil)
}

/*
*
todo 延期申请列表
*/
func WorkOrderList(c *gin.Context) {
	page := app.HandlePageNum(c)
	where := map[string]string{
		"where": " o.deleted_at=0 ",
		//"_group_by": "e.id",
		"_order_by": "e.id desc",
	}
	param := make(map[string]interface{})

	auditState := utils.ToInt(c.Query("audit_state"))
	if auditState > 0 {
		where["where"] = where["where"] + " AND e.audit_state = {{auditState}}"
		param["auditState"] = auditState - 1
	}

	keyword := c.Query("keyword")
	if keyword != "" {
		where["where"] = where["where"] + " AND (s.village like {{keyword}} )"
		param["keyword"] = "%" + keyword + "%"
	}

	type Admin struct {
		ID       int    `json:"id"`
		UserName string `json:"username"`
		Phone    string `json:"phone"`
	}

	type WorkExtension struct {
		Id                int    `json:"id"`
		WorkId            int    `json:"work_id"`      // 订单id
		Duration          int    `json:"duration"`     // 维修耗时
		Content           string `json:"content"`      // 维修反馈
		Type              int    `json:"type"`         // 延期类型 0节点延期 1：整体延期
		ManagerId         int    `json:"manager_id"`   // 项目经理id
		Pictures          string `json:"pictures"`     // 图片
		FinishedAt        int    `json:"finished_at"`  // 完成时间
		AuditType         int    `json:"audit_type"`   // 审核类型 0:无需审核 1:变更时间审核 2:完成审核
		AuditState        int    `json:"audit_state"`  // 审核状态 0:待审核 1:通过 2:不通过
		AuditId           int    `json:"audit_id"`     // 审核人
		AuditAt           int    `json:"audit_at"`     // 审核时间
		AuditRemark       string `json:"audit_remark"` // 审核备注
		CreatedAt         int    `json:"created_at"`
		UpdatedAt         int    `json:"updated_at"`
		SiteId            int64  `json:"site_id" label:"工地id" type:"int"  search:"="`                  //工地id
		Village           string `json:"village" label:"工地名称" `                                        //工地名称
		PkgId             int64  `json:"pkg_id" label:"套餐id" type:"int" prop:"add edit" search:"="`    //套餐id
		Pkg               int64  `json:"pkg_id" label:"套餐id" type:"int" prop:"add edit" search:"="`    //套餐id
		PickId            int64  `json:"pick_id" label:"套餐节点id" type:"int" prop:"add edit" search:"="` //套餐节点id
		WorkerId          int64  `json:"worker_id" label:"工人id" type:"int"  search:"="`                //工人id
		RoomType          int64  `json:"room_type" label:"一级" type:"int" prop:"add edit" search:"="`
		WorkerStartAt     int64  `json:"worker_start_at" label:"工人开始时间" prop:"add:false"`
		OrderStatus       int64  `json:"order_status"  type:"int" label:"工人接单状态" prop:"add:false"`
		ItemStatus        int64  `json:"item_status"  type:"int" label:"节点状态" prop:"add:false"` //节点状态：0：未完成  1：已完成
		OrderAcceptanceAt int64  `json:"order_acceptance_at"`                                   //工人接单时间
		ManageConfirmAt   int64  `json:"manager_confirm_at"`                                    //经理确认时间
		WorkerConfirmAt   int64  `json:"worker_confirm_at"`                                     //工人确认时间
		ManagerStatus     int64  `json:"manager_status"`                                        //经理确认状态
		WorkerStatus      int64  `json:"worker_status"`                                         //工人确认状态
		Starttime         int64  `json:"starttime"`                                             //工地开工时间
		Endtime           int64  `json:"endtime"`                                               //工地竣工时间
		Cycle             int64  `json:"cycle"`                                                 //工期
		PickName          string `json:"pick_name"`
		Standard          string `json:"standard"`

		ManagerInfo *Admin `json:"manager_info"`
	}

	workExtension := make([]WorkExtension, 0)
	err := order.GetListWidthOrder(where, param, page, &workExtension)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	managerIds := make([]int, 0)
	for _, v := range workExtension {
		if v.ManagerId > 0 {
			managerIds = append(managerIds, v.ManagerId)
		}
	}
	adminMap := make(map[int]*Admin, 0)
	if len(managerIds) > 0 {
		adminList := make([]*Admin, 0)
		if _, err := admin.GetAdmins(map[string]interface{}{"id in": managerIds}, []string{"id, username, phone"}, app.Page{}, &adminList); err == nil {
			for _, v := range adminList {
				adminMap[v.ID] = v
			}
		}
	}
	for k, v := range workExtension {
		if v.ManagerId > 0 && adminMap[v.ManagerId] != nil {
			v.ManagerInfo = adminMap[v.ManagerId]
		} else {
			v.ManagerInfo = &Admin{}
		}

		workExtension[k] = v
	}
	app.Success(c, workExtension)
}