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           //通过
)

const (
	OptionYes       = "是"
	OptionNo        = "否"
	OptionNoCertain = "不清楚"
)

/*机会-自查内容*/
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: "不清楚"}}
	var gIdx int64
	for i := range s {
		check := (s)[i]
		if gIdx == check.GroupId {
			continue
		}
		gIdx = check.GroupId
		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 (s SelfChecks) SetSelfChecksLevel1ByRule() (err error) {
	if len(s) == 0 {
		return
	}
	var gIdx = -1
	for i := 0; i < len(s); i++ {
		if gIdx < 0 || s[gIdx].GroupId != s[i].GroupId {
			gIdx = i
		} else {
			continue
		}
		hasSub := false
		var (
			cntYes       = 0 //是
			cntNo        = 0 //否
			cntUncertain = 0 //不确定
		)
		for j := i + 1; j < len(s); j++ {
			if s[i].GroupId == s[j].GroupId {
				if !hasSub {
					hasSub = true
				}
			} else {
				break
			}
			answer := s[j].Answer
			if strings.EqualFold(strings.TrimSpace(answer), OptionYes) {
				cntYes++
			} else if strings.EqualFold(strings.TrimSpace(answer), OptionNo) {
				cntNo++
			} else if strings.EqualFold(strings.TrimSpace(answer), OptionNoCertain) {
				cntUncertain++
			}
		}
		//只有一级维度的必须填写
		if hasSub {
			if cntYes > 0 {
				s[gIdx].Answer = OptionYes
			} else if cntNo > 0 {
				s[gIdx].Answer = OptionNo
			} else if cntUncertain > 0 {
				s[gIdx].Answer = OptionNoCertain
			}
		}
		if hasSub && cntYes == 0 && cntNo == 0 && cntUncertain == 0 {
			err = NewCustomMessage(2, fmt.Sprintf("未填写自查项:%v，二级维度至少需要填写一项", s[gIdx].CheckItem))
		}
		if !hasSub && len(s[gIdx].Answer) == 0 {
			err = NewCustomMessage(2, fmt.Sprintf("未填写自查项:%v", s[gIdx].CheckItem))
		}
	}
	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 {
}

/*SiftingResultsItemHistory 筛选历史*/
type SiftingResultsItemHistoryRequest struct {
	ChanceId int64 `json:"chanceId" valid:"Required"`
}
type SiftingResultsItemHistoryResponse struct {
	SiftingResults  SiftingResults `json:"siftingResults"`
	TotalSubmitters int            `json:"totalSubmitters"`
}

type SiftingResult struct {
	CheckId       int   `json:"checkId"`  //检查项id
	CheckParentId int64 `json:"parentId"` //项父id
	//GroupId int `json:"json:groupId"`//项分组id
	Title     string `json:"title"`     //标题
	CheckItem string `json:"checkItem"` //自查项

	TotalYes        int `json:"totalYes"`        //选择是的人数
	TotalNo         int `json:"totalNo"`         //选择否的人数
	TotalUncertain  int `json:"totalUncertain"`  //选择不清楚的人数
	TotalSubmitters int `json:"totalSubmitters"` //总提交人数

	SubSiftingResults SiftingResults `json:"subSiftingResults"`
}

type SiftingResults []SiftingResult

func (s SiftingResults) AddStatic(checkId int, answer string) {
	s.addStatic(checkId, answer)
}

//清空统计结果
func (s SiftingResults) ClearStatic() {
	for i := range s {
		s[i].TotalYes = 0
		s[i].TotalNo = 0
		s[i].TotalUncertain = 0
		s[i].TotalSubmitters = 0
		s[i].SubSiftingResults.ClearStatic()
	}
}

//添加统计
func (s SiftingResults) addStatic(checkId int, answer string) {
	for i := range s {
		if s[i].CheckId == checkId {
			var isAnswer = true
			switch answer {
			case OptionYes:
				s[i].TotalYes++
				break
			case OptionNo:
				s[i].TotalNo++
				break
			case OptionNoCertain:
				s[i].TotalUncertain++
				break
			default:
				isAnswer = false
				break
			}
			if isAnswer {
				s[i].TotalSubmitters++
			}
		}
		s[i].SubSiftingResults.AddStatic(checkId, answer)
	}
}

/*SiftingResultsItemDetail 筛选历史详情*/
type SiftingResultsItemDetailRequest struct {
	ChanceId int64 `json:"chanceId" valid:"Required"`
	CheckId  int   `json:"checkId" valid:"Required"` //检查项id
}
type SiftingResultsItemDetailResponse struct {
	SiftingResultDetails []SiftingResultDetail `json:"siftingResultDetails"`
	TotalSubmitters      int                   `json:"totalSubmitters"` //总提交人数
}

//筛选结果详情
type SiftingResultDetail struct {
	Option          string             `json:"option"` //选项：是 否 不清楚
	Items           SiftingCommitItems `json:"items"`
	TotalSubmitters int                `json:"totalSubmitters"` //总提交人数
}

//筛选结果提交人项
type SiftingCommitItems []SiftingCommitItem
type SiftingCommitItem struct {
	Provider *BaseUserInfo `json:"provider"`
	Reason   string        `json:"reason"` //理由
}