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"
	admin2 "zhiyuan/services/final/admin"
	"zhiyuan/services/form"

	"github.com/gogf/gf/v2/os/gtime"
)

var ASOrderRepair models.ASOrderRepair

func GetRepairList(where map[string]interface{}, fields []string, retVal interface{}) ([]*models.ASOrderRepair, error) {
	return ASOrderRepair.GetMulti(where, fields, retVal)
}

func GetRepairInfo(where map[string]interface{}, field []string, retVal interface{}) (*models.ASOrderRepair, error) {
	return ASOrderRepair.GetOne(where, field, retVal)
}

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

func GetListWidthOrder(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 e.*, " +
		"o.site_id,o.pkg_id,o.pick_id,o.cycle,o.example_at,o.order_acceptance_at,o.worker_start_at,o.worker_confirm_at,o.manager_confirm_at," +
		"o.room_type,o.worker_id,o.manager_id,o.worker_status,o.manager_status,o.item_status,o.order_status,o.pictures,o.confirm_type,o.acceptance_failed_remark," +
		"p.pick_name,p.standard," +
		"s.village as village" +
		" FROM " +
		" zy_work_extension e " +
		" LEFT JOIN zy_mat_pick_work o ON o.id=e.work_id " +
		" LEFT JOIN zy_mat_pick p ON p.id=o.pick_id " +
		" LEFT JOIN zy_final_site s ON s.id=o.site_id "
	return db.GetMultiRaw(sql, where, param, retVal)
}

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

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

func Repair(form form.OrderRepair, orderID int) error {
	orderInfo, _ := GetInfoByID(orderID, nil, nil)
	if orderInfo == nil {
		return errors.New("工单不存在")
	}
	if !utils.IsContain(orderParam.Allow.Feedback, orderInfo.State) {
		return errors.New("工单状态有误")
	}
	if form.Leader > 0 && form.Leader != orderInfo.Leader {
		return errors.New("权限有误")
	}
	formatTime := utils.DateParseUnix(form.FinishedAt, "Y-m-d H:i")
	if formatTime == 0 {
		return errors.New("日期格式有误")
	}
	if !admin.CheckAuth([]string{"aftersale:order:repair_no_pic"}, form.Leader) && form.Pics == "" {
		return errors.New("请上传现场图片")
	}
	supervisorInfo, _ := admin.GetOne(map[string]interface{}{"id": form.Supervisor}, nil, nil)

	audit_type := 0
	if orderInfo.StartTime != 0 {
		if form.State == 1 {
			audit_type = 2
		} else {
			now := time.Now().Unix()
			if now < orderInfo.EndTime-24*60*60 && int64(formatTime) > orderInfo.EndTime {
				audit_type = 1
			}
		}
	}

	// 已有记录
	repairMap := map[string]interface{}{
		"order_id":     orderID,
		"state":        form.State,
		"duration":     form.Duration,
		"content":      form.Content,
		"worker_name":  supervisorInfo.Username,
		"worker_phone": supervisorInfo.Phone,
		"supervisor":   form.Supervisor,
		"pics":         form.Pics,
		"finished_at":  formatTime,
		"audit_type":   audit_type,
	}
	repairID, err := db.InsertOne(ASOrderRepair.TableName(), repairMap)
	if err != nil {
		return errors.New("添加反馈失败")
	}
	if _, err = db.Update(ASOrder.TableName(), map[string]interface{}{"id": orderID}, map[string]interface{}{"repair_id": repairID}); err != nil {
		return errors.New("添加反馈失败")
	}

	AddTypeVisit(orderID, time.Now().Unix(), 3)
	AddTypeVisit(orderID, int64(formatTime), 4)
	return nil
}

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

func RepairCheck(repairID int, state int, adminID int, remark string) error {
	if state == 0 {
		return errors.New("状态有误")
	}
	repairInfo, _ := GetRepairInfo(map[string]interface{}{"id": repairID}, nil, nil)
	if repairInfo == nil {
		return errors.New("维修不存在")
	}
	if repairInfo.AuditType == 0 {
		return errors.New("维修无需审核")
	}
	if repairInfo.AuditState != 0 {
		return errors.New("维修已审核")
	}
	orderInfo, _ := GetInfoByID(repairInfo.OrderID, nil, nil)
	if orderInfo == nil {
		return errors.New("工单不存在")
	}
	if repairInfo.AuditType == 1 {
		if state == 1 {
			_, err := db.Update(ASOrder.TableName(), map[string]interface{}{"id": repairInfo.OrderID}, map[string]interface{}{"end_time": repairInfo.FinishedAt})
			if err != nil {
				return err
			}
		}
	} else if repairInfo.AuditType == 2 {
		if state == 1 {
			data := map[string]interface{}{"finish_state": 2, "finish_time": repairInfo.CreatedAt}
			if int64(repairInfo.CreatedAt) > orderInfo.EndTime {
				data["incomplete_count"] = orderInfo.IncompleteCount + 1
			}
			_, err := db.Update(ASOrder.TableName(), map[string]interface{}{"id": repairInfo.OrderID}, data)
			if err != nil {
				return err
			}
		} else {
			//typeInfo, _ := aftersale.GetTypeOne(map[string]interface{}{"id": orderInfo.MainType}, nil, nil)

			//now := time.Now()
			data := map[string]interface{}{
				"incomplete_count": orderInfo.IncompleteCount + 1,
				//"end_time":         now.AddDate(0, 0, typeInfo.RepairDays).Unix(),
			}
			_, err := db.Update(ASOrder.TableName(), map[string]interface{}{"id": repairInfo.OrderID}, data)
			if err != nil {
				return err
			}
		}
	}
	_, err := db.Update(ASOrderRepair.TableName(), map[string]interface{}{"id": repairID}, map[string]interface{}{
		"audit_state":  state,
		"audit_id":     adminID,
		"audit_at":     time.Now().Unix(),
		"audit_remark": remark,
	})
	if err != nil {
		return err
	}
	return nil
}

func ExtensionCheck(ExtensionID int, state int, adminID int, remark string) error {
	if state == 0 {
		return errors.New("状态有误")
	}

	var extensionInfo *final.WorkExtension
	err := db.GetOne(final.WorkExtension{}.TableName(), map[string]interface{}{"id": ExtensionID}, nil, &extensionInfo)

	if extensionInfo == nil {
		return errors.New("工单不存在")
	}

	if extensionInfo.AuditState != 0 {
		return errors.New("工单已审核")
	}
	workInfo, _ := GetWorkInfoByID(extensionInfo.WorkId, nil, nil)
	if workInfo == nil {
		return errors.New("工单不存在")
	}

	fmt.Println("------------workInfo-----------", workInfo)

	//加载节假日
	holidays := admin2.LoadHolidays()

	extensionDay, err := admin2.CalculateEndDate(holidays, gtime.New(workInfo.ExampleAt).Format("Y-m-d"), extensionInfo.Duration)
	if err != nil {
		return err
	}

	auditState := 2

	if state == 1 {
		//1 修改extension表状态
		auditState = 1

		//节点延期
		if extensionInfo.Type == 0 {
			_, err := db.Exec("UPDATE zy_mat_pick_work SET example_at = ? WHERE id= ?", []interface{}{
				extensionDay,
				extensionInfo.WorkId,
			})
			if err != nil {
				fmt.Println(err)
				return err
			}

		} else {
			//整体延期
			_, err := db.Exec("UPDATE zy_mat_pick_work SET example_at = DATE_ADD(example_at, INTERVAL ? DAY) WHERE site_id= ?", []interface{}{
				extensionInfo.Duration,
				workInfo.SiteId,
			})
			if err != nil {
				fmt.Println(err)
				return err
			}
		}
	}

	//更新extension表状态
	_, err = db.Exec("UPDATE zy_work_extension SET "+
		"audit_id = ?,"+
		"audit_at = ?, "+
		"audit_remark = ?, "+
		"audit_state = ? "+
		"WHERE id= ?", []interface{}{
		adminID,
		time.Now().Unix(),
		remark,
		auditState,
		ExtensionID,
	})
	if err != nil {
		fmt.Println(err)
		return err
	}
	return nil
}