package order

import (
	"errors"
	"fmt"
	"time"
	"zhiyuan/models"
	"zhiyuan/models/final"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	orderParam "zhiyuan/pkg/param/order"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/admin"
	"zhiyuan/services/aftersale"
	"zhiyuan/services/form"
	"zhiyuan/services/sms"
	"zhiyuan/services/structs"
	"zhiyuan/services/user"
)

var ASOrder models.ASOrder
var ASOrderDetail models.ASOrderDetail
var ASPickWork final.MatPickWork

func GetList(where map[string]interface{}, fields []string, page app.Page, retVal interface{}) ([]*models.ASOrder, error) {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_limit"] = db.GetOffset(uint(page.PageNum), uint(page.PageSize))
	}
	return ASOrder.GetMulti(where, fields, retVal)
}

func GetLists(where map[string]string, param map[string]interface{}, page app.Page, retVal interface{}) error {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_page_num"] = db.ToString(page.PageNum)
		where["_page_size"] = db.ToString(page.PageSize)
	}
	sql := "SELECT o.* FROM zy_as_order o"
	return db.GetMultiRaw(sql, where, param, retVal)
}

func GetListWidthVisit(where map[string]string, param map[string]interface{}, page app.Page, retVal interface{}) error {
	if page.PageNum > 0 && page.PageSize > 0 {
		where["_page_num"] = db.ToString(page.PageNum)
		where["_page_size"] = db.ToString(page.PageSize)
	}
	sql := "SELECT o.* FROM zy_as_order o LEFT JOIN zy_as_order_visit v ON o.id=v.order_id AND v.deleted_at=0"
	return db.GetMultiRaw(sql, where, param, retVal)
}

func GetListWidthForceCompleted(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	sql := "SELECT o.*, if(o.state=90,90,if(o.is_force=0,o.state,100)) as `cstate`, if(o.finish_state=1 and UNIX_TIMESTAMP()>o.end_time,1,0) as `repair_timeout` FROM zy_as_order o"
	return db.GetMultiRaw(sql, where, param, retVal)
}

func GetListWidthDetail(where map[string]string, param map[string]interface{}, retVal interface{}) error {
	sql := "SELECT o.*, if(o.state=90,90,if(o.is_force=0,o.state,100)) as `cstate`, if(o.finish_state=1 and UNIX_TIMESTAMP()>o.end_time,1,0) as `repair_timeout`, d.province, d.city, d.region, d.address, d.content, d.pics, d.remarks FROM zy_as_order o LEFT JOIN zy_as_order_detail d ON o.id=d.order_id"
	return db.GetMultiRaw(sql, where, param, retVal)
}

func GetCountWidthDetail(where string, param map[string]interface{}) (int64, error) {
	sql := "zy_as_order o LEFT JOIN zy_as_order_detail d ON o.id=d.order_id WHERE " + where
	return db.CountRaw(sql, param)
}

func Count(where map[string]interface{}) (int64, error) {
	return db.Count(ASOrder.TableName(), where)
}

func GetOneWithDetail(where string, param map[string]interface{}, retVal interface{}) error {
	sql := "SELECT o.*, d.province, d.city, d.region, d.address, d.content, d.pics FROM zy_as_order o LEFT JOIN zy_as_order_detail d ON o.id=d.order_id"
	return db.GetMultiRaw(sql, map[string]string{"where": where, "_page_size": "1", "_page_num": "1"}, param, retVal)
}

func GetInfoByID(id int, fields []string, retVal interface{}) (*models.ASOrder, error) {
	return ASOrder.GetOne(map[string]interface{}{"id": id}, fields, retVal)
}

func GetWorkInfoByID(id int, fields []string, retVal interface{}) (*final.MatPickWork, error) {
	return ASPickWork.GetOne(map[string]interface{}{"id": id}, fields, retVal)
}

func Del(id int) error {
	_, err := db.DeleteSoft(ASOrder.TableName(), map[string]interface{}{"id": id})
	return err
}

func Add(form form.OrderAdd) (int, error) {

	// 添加订单
	orderMap := map[string]interface{}{
		"order_no":  utils.RandomOrder("10", 2),
		"main_type": form.MainType,
		"sub_type":  form.SubType,
		"state":     orderParam.State.Created.ID,
		"house_id":  form.HouseID,
		"type":      form.Typ,
	}
	if form.Typ == 1 {
		o, err := ASOrder.GetOne(map[string]interface{}{
			"house_id":     form.HouseID,
			"state not in": []int{orderParam.State.Completed.ID, orderParam.State.Revoked.ID},
			"deleted_at":   0,
		}, nil, nil)
		if err != nil {
			return 0, err
		}
		if o != nil {
			return 0, errors.New("该房屋存在未完结的报修")
		}
	}
	var houseInfo *structs.HouseList
	if _, err := user.GetHouseInfoByID(form.HouseID, nil, &houseInfo); err != nil {
		return 0, errors.New("房屋信息有误")
	}
	/*is := false
	uid := 0
	for i, userid := range strings.Split(houseInfo.UserIDs, ",") {
		id, _ := db.ToInt64(userid)
		if i == 0 {
			uid = int(id)
		}
		if int(id) == form.UserID {
			is = true
		}
	}
	if form.UserID > 0 && !is {
		return 0, errors.New("房屋信息不匹配")
	}
	if form.UserID > 0 {
		uid = form.UserID
	}*/
	/*if form.UserID > 0 && houseInfo.UserID != form.UserID {
		return 0, errors.New("房屋信息不匹配")
	}
	orderMap["user_id"] = uid
	if userInfo, _ := user.GetOne(map[string]interface{}{"id": uid}, nil, nil); userInfo == nil {
		return 0, errors.New("用户不存在")
	} else {
		orderMap["link_name"] = userInfo.Name
		orderMap["link_phone"] = userInfo.Phone
	}
	if utils.ToInt64(houseInfo.WarrantyStart) > 0 {
		var typeInfo *structs.WarrantyType
		aftersale.GetTypeOne(map[string]interface{}{"id": form.MainType}, nil, &typeInfo)
		user.GetWarrantyPeriod(utils.ToInt64(houseInfo.WarrantyStart), typeInfo, houseInfo)
		orderMap["warranty_start"] = houseInfo.WarrantyStart
		orderMap["warranty_end"] = typeInfo.WarrantyEnd
		orderMap["in_warranty"] = typeInfo.InWarranty
	}
	if userInfo, err := user.GetOne(map[string]interface{}{"id": uid}, nil, nil); err == nil {
		//if userInfo, err := user.GetOne(map[string]interface{}{"id": houseInfo.UserID}, nil, nil); err == nil {
		orderMap["site_id"] = userInfo.SiteID
	}*/
	if form.UserID > 0 && houseInfo.UserID != form.UserID {
		return 0, errors.New("房屋信息不匹配")
	}
	orderMap["user_id"] = houseInfo.UserID
	orderMap["link_name"] = houseInfo.LinkName
	orderMap["link_phone"] = houseInfo.LinkPhone
	if utils.ToInt64(houseInfo.WarrantyStart) > 0 {
		var typeInfo *structs.WarrantyType
		aftersale.GetTypeOne(map[string]interface{}{"id": form.MainType}, nil, &typeInfo)
		user.GetWarrantyPeriod(utils.ToInt64(houseInfo.WarrantyStart), typeInfo, houseInfo)
		orderMap["warranty_start"] = houseInfo.WarrantyStart
		orderMap["warranty_end"] = typeInfo.WarrantyEnd
		orderMap["in_warranty"] = typeInfo.InWarranty
	}
	if userInfo, err := user.GetOne(map[string]interface{}{"id": houseInfo.UserID}, nil, nil); err == nil {
		orderMap["site_id"] = userInfo.SiteID
	}
	orderID, err := db.InsertOne(ASOrder.TableName(), orderMap)
	if err != nil {
		return 0, errors.New("添加订单失败")
	}

	// 添加订单明细
	detailMap := map[string]interface{}{
		"order_id": orderID,
		"address":  houseInfo.Address,
		"content":  form.Content,
		"pics":     form.Pics,
	}
	_, err = db.InsertOne(ASOrderDetail.TableName(), detailMap)
	if err != nil {
		return 0, errors.New("添加订单明细失败")
	}

	// 添加订单 event
	err = AddEvent(EventForm{OrderID: utils.ToInt(orderID), OrderState: orderParam.State.Created.ID})
	if err != nil {
		return 0, err
	}
	return utils.ToInt(orderID), nil
}

func Revoke(form form.OrderRevoke, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if form.UserID > 0 && orderInfo.UserID != form.UserID {
		return errors.New("没有权限撤销该工单")
	}
	if !utils.IsContain(orderParam.Allow.Revoke, orderInfo.State) {
		return errors.New("该工单不允许撤销")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"state": orderParam.State.Revoked.ID})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Revoked.ID,
		Content:    "撤销原因：" + form.Content,
		Servicer:   form.Servicer,
	})
}

func Suspend(form form.OrderSuspend, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if !utils.IsContain(orderParam.Allow.Suspend, orderInfo.State) {
		return errors.New("该工单不允许待定")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"state": orderParam.State.Suspending.ID})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Suspending.ID,
		Content:    "待定原因：" + form.Content,
		Servicer:   form.Servicer,
	})
}

func Check(form form.OrderCheck, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if !utils.IsContain(orderParam.Allow.Check, orderInfo.State) {
		return errors.New("该工单不允许审核")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"state":              orderParam.State.Checked.ID,
		"maintenance_remark": form.Remark,
	})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Checked.ID,
		Servicer:   form.Servicer,
		Content:    form.Remark,
	})
}

func Remark(form form.OrderRemark, id int) error {
	db.Update(ASOrderDetail.TableName(), map[string]interface{}{"order_id": id}, map[string]interface{}{"remarks": form.Content})
	return nil
}

func Issue(form form.OrderIssue, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	DelIssueByOrder(id)
	issueList := make([]map[string]interface{}, 0)
	for _, v := range form.IssueList {
		issueMap := map[string]interface{}{
			"order_id":    id,
			"director":    v.Director,
			"issue_id":    v.IssueID,
			"issue_desc":  v.IssueDesc,
			"brand":       v.Brand,
			"leader":      orderInfo.Leader,
			"in_warranty": orderInfo.InWarranty,
		}
		if v.Director == 1 && v.Brand == 0 {
			return errors.New("材料商问题需要选择主材品牌")
		}
		issueList = append(issueList, issueMap)
	}
	AddMultiIssue(issueList)
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{"is_issue": 1})
	return err
}

func Complete(form form.OrderComplete, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	force := form.IsForce
	if form.IsForce > 0 {
		if !admin.CheckAuth([]string{"aftersale:order:force_complete"}, form.Servicer) || !utils.IsContain(orderParam.Allow.ForceComplete, orderInfo.State) {
			return errors.New("该工单不允许强制完结")
		}

	} else if !utils.IsContain(orderParam.Allow.Complete, orderInfo.State) {
		return errors.New("该工单不允许完结")
	}
	fmt.Println(orderInfo)
	if orderInfo.Leader == 0 {
		return errors.New("该工单还没有分配")
	}
	data := map[string]interface{}{
		"is_force":       force,
		"statement_time": time.Now().Unix(),
	}
	if force == 0 {
		data["state"] = orderParam.State.Completed.ID
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, data)
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Completed.ID,
		Servicer:   form.Servicer,
	})
}

func ReAllot(form form.OrderAllot, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if !utils.IsContain(orderParam.Allow.ReAllot, orderInfo.State) {
		return errors.New("该工单不允许重新分配")
	}
	if orderInfo.Leader == 0 {
		return errors.New("该工单还未分配")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"leader":        form.Leader,
		"state":         orderParam.State.Allotted.ID,
		"dispatch_time": time.Now().Unix(),
	})
	if err != nil {
		return err
	}

	// 发送派单短信
	SendAllotSms(form.Leader)

	AddTypeVisit(id, time.Now().Unix(), 1)
	// 获取之前的 event
	eventInfo, err := GetEventInfo(map[string]interface{}{
		"order_id":    id,
		"order_state": orderParam.State.Allotted.ID,
	}, nil, nil)
	if err != nil || orderInfo == nil {
		return errors.New("获取工单进度失败")
	}

	// 添加订单 event
	return AddEvent(EventForm{
		EventID:    eventInfo.ID,
		OrderID:    id,
		OrderState: orderParam.State.Allotted.ID,
		Servicer:   form.Servicer,
		Leader:     form.Leader,
	})
}

func Allot(form form.OrderAllot, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if orderInfo.Leader > 0 {
		return ReAllot(form, id)
	}
	if !utils.IsContain(orderParam.Allow.Allot, orderInfo.State) {
		return errors.New("该工单不允许分配")
	}
	typeInfo, _ := aftersale.GetTypeOne(map[string]interface{}{"id": orderInfo.MainType}, nil, nil)

	now := time.Now()
	data := map[string]interface{}{
		"state":         orderParam.State.Allotted.ID,
		"leader":        form.Leader,
		"dispatch_time": now.Unix(),
	}
	if typeInfo.RepairDays != 0 {
		data["start_time"] = now.Unix()
		data["end_time"] = now.AddDate(0, 0, typeInfo.RepairDays).Unix()
		data["finish_state"] = 1
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, data)
	if err != nil {
		return err
	}

	AddTypeVisit(id, time.Now().Unix(), 1)
	// 发送派单短信
	SendAllotSms(form.Leader)

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Allotted.ID,
		Servicer:   form.Servicer,
		Leader:     form.Leader,
	})
}

func SendAllotSms(leader int) {
	go func() {
		if adminInfo, _ := admin.GetOne(map[string]interface{}{"id": leader}, []string{"phone"}, nil); adminInfo != nil {
			sms.SendAftersaleOrderAllot(adminInfo.Phone)
		}
	}()
}

func Schedule(form form.OrderSchedule, id int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	formatTime := utils.DateParseUnix(form.Date, "Y-m-d H:i")
	if formatTime == 0 {
		return errors.New("日期格式有误")
	}
	if !utils.IsContain(orderParam.Allow.Repairing, orderInfo.State) {
		return errors.New("工单状态有误")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"state":         orderParam.State.Repairing.ID,
		"schedule_time": formatTime,
	})
	if err != nil {
		return err
	}

	AddTypeVisit(id, int64(formatTime), 2)
	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Repairing.ID,
		Leader:     form.Leader,
		Date:       form.Date,
	})
}

func Confirm(id int, userID int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if userID > 0 && orderInfo.UserID != userID {
		return errors.New("只能操作自己的订单")
	}
	if !utils.IsContain(orderParam.Allow.Confirm, orderInfo.State) {
		return errors.New("该工单不允许确认完成")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"state": orderParam.State.Confirmed.ID,
	})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Confirmed.ID,
	})
}

func SupConfirm(id int, adminID int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if !utils.IsContain(orderParam.Allow.SupConfirm, orderInfo.State) {
		return errors.New("该工单不允许监理确认")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"state":       orderParam.State.SupConfirmed.ID,
		"supervisor":  adminID,
		"taking_time": time.Now().Unix(),
	})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.SupConfirmed.ID,
		Leader:     adminID,
	})
}

func Repaired(id int, adminID int) error {
	orderInfo, err := GetInfoByID(id, nil, nil)
	if err != nil {
		return err
	}
	if orderInfo.Leader != adminID {
		return errors.New("只能完成自己的订单")
	}
	if orderInfo.RepairID == 0 {
		return errors.New("请先填写反馈")
	}
	if !utils.IsContain(orderParam.Allow.Repaired, orderInfo.State) {
		return errors.New("订单状态有误")
	}
	_, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": id}, map[string]interface{}{
		"state": orderParam.State.Repaired.ID,
	})
	if err != nil {
		return err
	}

	// 添加订单 event
	return AddEvent(EventForm{
		OrderID:    id,
		OrderState: orderParam.State.Repaired.ID,
		Leader:     adminID,
	})
}