package protocol

import (
	"bytes"
	"encoding/json"
	"fmt"
	"gitlab.fjmaimaimai.com/mmm-go/gocomm/pkg/log"
	"opp/internal/utils"
	"strings"
)

const (
	TypeSubmit  = iota + 1 //提交者类型
	TypeApprove            //审核人类型
)

//提交状态
const (
	Submiting = iota //待我提交
	Submited         //我已提交
)

//通过状态
const (
	None    = iota //未提交
	Waiting        //已提交待处理
	Reject         //退回
	Pass           //通过
)

/*机会-自查内容*/
var CheckOptionsCommit = []CheckOption{{Item: "是", NeedOther: false}, {Item: "否", NeedOther: false}, {Item: "不清楚", NeedOther: false}}
var CheckOptionsApprove = []CheckOption{{Item: "是", NeedOther: false}, {Item: "否", NeedOther: true}, {Item: "不清楚", NeedOther: false}}

//自查结果列表
type SelfCheckResults []selfCheckResult
type selfCheckResult struct {
	Item  string `json:"item"`
	Total int    `json:"total"`
}

//自查项列表
func NewSelfChecks(data string) (rsp SelfChecks) {
	if len(data) == 0 {
		return
	}
	e := json.Unmarshal([]byte(data), &rsp)
	if e != nil {
		log.Error(e)
	}
	return
}

type SelfChecks []SelfCheck

type SelfCheck struct {
	CheckItem string `json:"checkItem"`
	GroupId   int64  `json:"groupId"` //分组
	Answer    string `json:"answer,omitempty"`
	Reason    string `json:"reason,omitempty"`

	Id       int64 `json:"id"`
	ParentId int64 `json:"parentId"`
}

func (c SelfCheck) Key() string {
	return fmt.Sprintf("%v-%v", c.GroupId, c.CheckItem)
}

//统计自查结果
func (s SelfChecks) Static() SelfCheckResults {
	if len(s) == 0 {
		return []selfCheckResult{}
	}
	results := []selfCheckResult{{Item: "是"}, {Item: "否"}, {Item: "不清楚"}}
	for i := range s {
		check := (s)[i]
		for k := range results {
			if strings.EqualFold(results[k].Item, strings.TrimSpace(check.Answer)) {
				results[k].Total = results[k].Total + 1
				break
			}
		}
	}
	return SelfCheckResults(results)
}

//自查校验
func (s SelfChecks) Valid() (err error) {
	if len(s) == 0 {
		return
	}
	for i := range s {
		c := s[i]
		if c.GroupId == 0 {
			err = NewErrWithMessage(2)
			return
		}
		if len(c.CheckItem) == 0 {
			err = NewErrWithMessage(2)
			return
		}
		if len(c.Answer) == 0 {
			err = NewCustomMessage(2, "自查项未填写")
			return
		}
	}
	return
}

//自查内容
func (s SelfChecks) String() string {
	var buf bytes.Buffer
	for i := range s {
		c := s[i]
		if len(c.Reason) == 0 {
			buf.WriteString(fmt.Sprintf("\n%v：%v；", c.CheckItem, c.Answer))
		} else {
			buf.WriteString(fmt.Sprintf("\n%v：%v，理由：%v；", c.CheckItem, c.Answer, c.Reason))
		}
	}
	return buf.String()
}
func (s SelfChecks) Compare(dst string) (rspChecks SelfChecks, err error) {
	var (
		dstChecks SelfChecks
		mapChecks = make(map[string]SelfCheck)
	)
	rspChecks = make([]SelfCheck, 0)
	if len(s) == 0 {
		return
	}
	utils.JsonUnmarshal(dst, &dstChecks)
	if len(s) != len(dstChecks) {
		err = NewCustomMessage(1, "自查项有误")
		log.Error(err, s, dstChecks)
		return
	}
	for i := range dstChecks {
		c := dstChecks[i]
		mapChecks[c.Key()] = c
	}
	for i := range s {
		c := s[i]
		if v, ok := mapChecks[c.Key()]; ok {
			//回答不一直
			if !strings.EqualFold(c.Answer, v.Answer) {
				rspChecks = append(rspChecks, c)
				continue
			}
			if len(c.Reason) > 0 {
				rspChecks = append(rspChecks, c)
				continue
			}
		}
	}
	return
}

//自查问题
func NewCheckQuestion(checkItem, title string, groupId int64, ops []CheckOption) *CheckQuestion {
	return &CheckQuestion{
		CheckItem:    checkItem,
		Title:        title,
		GroupId:      groupId,
		CheckOptions: ops,
	}
}

type CheckQuestion struct {
	Id       int64 `json:"id"`
	ParentId int64 `json:"parentId"`

	CheckItem    string        `json:"checkItem"`
	Title        string        `json:"title"`
	GroupId      int64         `json:"groupId"`
	Answer       string        `json:"answer,omitempty"`
	Reason       string        `json:"reason,omitempty"`
	CheckOptions []CheckOption `json:"options"`

	Required bool `json:"required"` //是否必填
}
type CheckOption struct {
	Item      string `json:"item"`
	NeedOther bool   `json:"needOther"` //是否需填写其他的内容【1：需要】【2：不需要】
}

/*CheckQuestions  自查问题列表*/
type CheckQuestionsRequest struct {
	Type     int   `json:"type"` //0.自查  1.筛选结果
	ChanceId int64 `json:"chanceId" valid:"Required"`
}
type CheckQuestionsResponse struct {
	Questions []*CheckQuestion `json:"questions"`
}

//SiftingPool 筛选池
type SiftingPoolRequest struct {
	PageInfo
	Uid          int64 `json:"uid"`          //注入用户 测试使用
	SubmitStatus int   `json:"submitStatus"` //0:待我提交 1:提交
	SiftedStatus int   `-`                   //筛选状态 1:提交中 2:通过 3:不通过
}
type SiftingPoolResponse struct {
	ChancePoolResponse
}

/*筛选结果 SiftingResults */
type SiftingResultsRequest struct {
	PageInfo
	Uid          int64 `json:"uid"`           //注入用户 测试使用
	SiftedStatus int   `json:"siftingStatus"` //筛选状态 1:待处理 2:通过 3:不通过
}
type SiftingResultsResponse struct {
	ChancePoolResponse
}

/*SubmitChecks 提交自查*/
type SubmitChecksRequest struct {
	//Type  int `json:"type"` //1.审核人
	Uid        int64      `json:"uid"`
	ChanceId   int64      `json:"chanceId" valid:"Required"`
	SelfChecks SelfChecks `json:"selfChecks"`
}
type SubmitChecksResponse struct {
}