package work

import (
	"fmt"
	"strings"
	"time"
	"zhiyuan/models"
	"zhiyuan/pkg/app"
	"zhiyuan/pkg/db"
	"zhiyuan/pkg/utils"
	"zhiyuan/services/geo"
	"zhiyuan/services/work/worker"

	"github.com/gin-gonic/gin"
	"github.com/tealeg/xlsx/v3"
)

func WorkerList(c *gin.Context) {
	page := app.HandlePageNums(c)
	where := map[string]string{
		"where":     "`zy_worker`.`id`>0",
		"_group_by": "`zy_worker`.`id`",
		"_order_by": "`zy_worker`.`id` desc",
	}
	if page.PageSize != 0 {
		where["_page_size"] = utils.ToStr(page.PageSize)
		where["_page_num"] = utils.ToStr(page.PageNum)
	}
	param := make(map[string]interface{})

	name := c.Query("name")
	if name != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`name` LIKE {{name}}"
		param["name"] = "%" + name + "%"
	}

	phone := c.Query("phone")
	if phone != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`phone` LIKE {{phone}}"
		param["phone"] = "%" + phone + "%"
	}

	idcode := c.Query("idcode")
	if idcode != "" {
		where["where"] = where["where"] + " AND `zy_worker`.`idcode` LIKE {{idcode}}"
		param["idcode"] = "%" + idcode + "%"
	}

	typeId := c.Query("type_id")
	if typeId != "" {
		where["where"] = where["where"] + " AND FIND_IN_SET({{type_id}}, `zy_worker`.`type_ids`)"
		param["type_id"] = typeId
	}

	state := utils.ToInt(c.Query("state"))
	if state != 0 {
		where["where"] = where["where"] + " AND `zy_worker`.`state`={{state}}"
		param["state"] = state
	}

	total, err := worker.CountRaw(where["where"], param)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	type WorkerList struct {
		ID        int    `json:"id"`
		Name      string `json:"name"`
		Phone     string `json:"phone"`
		TypeIds   string `json:"type_ids"`
		TypeNames string `json:"type_names"`
		Idcode    string `json:"idcode"`
		Idcard1   string `json:"idcard1"`
		Idcard2   string `json:"idcard2"`
		State     string `json:"state"`
		CreatedAt int    `json:"created_at"`
		UpdatedAt int    `json:"updated_at"`
	}
	workerList := make([]WorkerList, 0)
	if err = worker.GetWorkersRaw(where, param, &workerList); err != nil {
		app.Error(c, err.Error())
		return
	}

	data := gin.H{
		"list":  workerList,
		"total": total,
		"limit": page.PageSize,
	}
	app.Success(c, data)
}

func WorkerVerify(c *gin.Context) {
	id := utils.ToInt(c.Param("id"))
	if id <= 0 {
		app.ErrorMsg(c, "worker id must be a number", nil)
		return
	}

	err := worker.VerifyByID(id)
	if err != nil {
		app.ErrorMsg(c, err.Error(), nil)
		return
	}
	app.Success(c, nil)
}

func WorkerImport(c *gin.Context) {
	file, err := c.FormFile("file")
	if err != nil {
		app.Error(c, fmt.Sprintf("get form err: %s", err.Error()))
		return
	}
	fileExt := utils.FileExt(file.Filename)
	attachKey := utils.RandomStr() + fileExt
	file.Filename = "data/" + attachKey
	if err := c.SaveUploadedFile(file, file.Filename); err != nil {
		app.Error(c, fmt.Sprintf("上传文件失败%s", err.Error()))
		return
	}
	wb, err := xlsx.OpenFile(file.Filename)
	if err != nil {
		app.Error(c, err.Error())
		return
	}
	sh, ok := wb.Sheet["Sheet1"]
	if !ok {
		fmt.Println("Sheet does not exist")
		return
	}

	typeList := make([]models.WorkType, 0)
	db.GetModel(map[string]interface{}{}, &typeList)

	datas := make([]map[string]interface{}, 0)
	headers := make([]string, 0)

	err = sh.ForEachRow(func(r *xlsx.Row) error {
		if r.GetCoordinate() <= 0 {
			err := r.ForEachCell(func(c *xlsx.Cell) error {
				headers = append(headers, c.String())
				return nil
			})
			if err != nil {
				return err
			}
		} else {
			var data models.Worker
			for i, header := range headers {
				value := r.GetCell(i).String()
				switch header {
				case "姓名":
					data.Name = value
				case "电话号码":
					data.Phone = value
				case "性别":
					sex := 0
					if value == "男" {
						sex = 1
					} else if value == "女" {
						sex = 2
					}
					data.Sex = sex
				case "年龄":
					age, _ := db.ToInt64(value)
					data.Age = int(age)
				case "身份证号":
					data.Idcode = value
				case "工种":
					types := make([]string, 0)

					nameList := strings.Split(value, ",")
					for _, name := range nameList {
						if name != "" {
							for _, typ := range typeList {
								if strings.Index(typ.Name, name) == 0 {
									types = append(types, db.ToString(typ.ID))
									break
								}
							}
						}
					}

					data.TypeIds = strings.Join(types, ",")
				case "所在区域":
					names := strings.Split(value, "/")
					code := ""
				out:
					for _, name := range names {
						list, err := geo.Lower(code)
						if err != nil {
							break
						}
						for _, l := range list {
							if n, ok := l["name"]; ok {
								if name == db.ToString(n) {
									if c, ok := l["code"]; ok {
										code = db.ToString(c)
										continue out
									}
								}
							}
						}
						break
					}
					data.Areacode = code
				case "是否买保险":
					insure := 0
					if value == "是" {
						insure = 1
					}
					data.Insure = insure
				case "保险开始日期":
					insure_start, _ := time.ParseInLocation("2006-01-02", value, time.Local)
					s := int(insure_start.Unix())
					if s > 0 {
						s = 0
					}
					data.InsureStart = s
				case "保险结束日期":
					insure_end, _ := time.ParseInLocation("2006-01-02", value, time.Local)
					s := int(insure_end.Unix())
					if s > 0 {
						s = 0
					}
					data.InsureEnd = s
				case "开户行":
					data.BankName = value
				case "银行卡号":
					data.BankCardNo = value
				default:
				}
			}
			if data.Name == "" || data.Phone == "" {
				return nil
			}
			var worker models.Worker
			db.GetModel(map[string]interface{}{
				"phone":      data.Phone,
				"deleted_at": 0,
			}, &worker)
			da := map[string]interface{}{
				"name":         data.Name,
				"phone":        data.Phone,
				"sex":          data.Sex,
				"age":          data.Age,
				"idcode":       data.Idcode,
				"type_ids":     data.TypeIds,
				"areacode":     data.Areacode,
				"insure":       data.Insure,
				"insure_start": data.InsureStart,
				"insure_end":   data.InsureEnd,
				"bank_name":    data.BankName,
				"bank_card_no": data.BankCardNo,
			}
			if worker.ID == 0 {
				datas = append(datas, da)
			} else {
				if worker.Name == data.Name {
					err := db.UpdateModel(db.Type(worker), int64(worker.ID), da)
					if err != nil {
						return err
					}
				}
			}
		}
		return nil
	})

	if err != nil {
		app.Error(c, err.Error())
		return
	}
	db.InsertModels(db.Type(models.Worker{}), datas)
	app.Success(c, nil)
}