package manage

import (
	"SciencesServer/app/api/admin/model"
	"SciencesServer/app/basic/config"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/app/session"
	config2 "SciencesServer/config"
	"SciencesServer/lib"
	"SciencesServer/serve/orm"
	"SciencesServer/utils"
	"errors"
	"fmt"
	"gorm.io/gorm"
	"strings"
	"time"
)

type Expert struct {
	*session.Admin
}

type ExpertHandle func(session *session.Admin) *Expert

type (
	// ExpertInstance 专家信息
	ExpertInstance struct {
		ID               string   `json:"id"`
		Name             string   `json:"name"`
		Industrys        []string `json:"industrys"`
		ResearchName     string   `json:"research_name"`
		LaboratoryName   string   `json:"laboratory_name"`
		AchievementCount int      `json:"achievement_count"`
		PatentCount      int      `json:"patent_count"`
		Address          string   `json:"address"`
		model2.Examine
		CreatedAt time.Time `json:"created_at"`
		Area      string    `json:"area"`
	}
	// ExpertDetail 专家详细信息
	ExpertDetail struct {
		ID           string `json:"id"`
		TenantID     string `json:"tenant_id"`
		ResearchID   string `json:"research_id"`
		LaboratoryID string `json:"laboratory_id"`
		*model2.ManageExpert
		Industrys []*config.Industry `json:"industrys"`
		Keywords  []string           `json:"keywords"`
		Researchs []string           `json:"researchs"`
		Area      string             `json:"area"`
	}
	// ExpertPatent 专家专利信息
	ExpertPatent struct {
		ID string `json:"id"`
		*model.ManageExpertPatent
		IsBind bool `json:"is_bind"`
	}

	// ExpertExcel 专家表格数据
	ExpertExcel struct {
		Name          string `json:"name" xlsx:"专家姓名"`
		Province      string `json:"province" xlsx:"所在省"`
		City          string `json:"city" xlsx:"所在市"`
		District      string `json:"district" xlsx:"所在区"`
		Address       string `json:"address" xlsx:"详细地址"`
		Site          string `json:"site" form:"所属站点"`
		Industry      string `json:"industry" xlsx:"所属领域"`
		Research      string `json:"research" xlsx:"所属单位"`
		Laboratory    string `json:"laboratory" xlsx:"所属实验室"`
		School        string `json:"school" xlsx:"毕业院校"`
		Keyword       string `json:"keyword" xlsx:"关键词"`
		Education     string `json:"education" xlsx:"最高学历"`
		Major         string `json:"major" xlsx:"主修专业"`
		Job           string `json:"job" xlsx:"职务"`
		Title         string `json:"title" xlsx:"职称"`
		WorkAt        string `json:"work_at" xlsx:"从业时间"`
		Gender        string `json:"gender" xlsx:"性别"`
		ResearchWhere string `json:"research_where" xlsx:"研究方向"`
		Mobile        string `json:"mobile" xlsx:"手机号"`
		Introduce     string `json:"introduce" xlsx:"个人简介"`
		Technology    string `json:"technology" xlsx:"核心技术及产品"`
		Scene         string `json:"scene" xlsx:"应用场景"`
		Tag1          string `json:"tag_1" xlsx:"代表成果及合作模式"`
		Tag2          string `json:"tag_2" xlsx:"已合作企业"`
		Tag3          string `json:"tag_3" xlsx:"想合作企业"`
	}
	// ExpertExcelInfo 表格详细信息
	ExpertExcelInfo struct {
		*model2.ManageExpert
		Tag2 string `json:"tag_2" xlsx:"已合作企业"`
		Tag3 string `json:"tag_3" xlsx:"想合作企业"`
	}
)

// Instance 首页信息
func (c *Expert) Instance(tenantID uint64, name string, examineStatus int, page, pageSize int) (*controller.ReturnPages, error) {
	mManageExpert := model.NewManageExpert()

	where := make([]*model2.ModelWhere, 0)

	if c.TenantID > 0 {
		where = append(where, model2.NewWhere("e.tenant_id", c.TenantID))
	}
	if tenantID > 0 {
		where = append(where, model2.NewWhere("e.tenant_id", tenantID))
	}
	if name != "" {
		where = append(where, model2.NewWhereLike("e.name", name))
	}
	if examineStatus > 0 {
		where = append(where, model2.NewWhere("e.examine_status", examineStatus))
	}
	var count int64

	out, err := mManageExpert.Experts(page, pageSize, &count, where...)

	if err != nil {
		return nil, err
	}
	list := make([]*ExpertInstance, 0)

	for _, v := range out {
		_industrys := make([]string, 0)

		for _, v := range v.GetIndustryAttribute() {
			_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "/").Value)
		}
		// 研究机构，实验室
		list = append(list, &ExpertInstance{ID: v.GetEncodeID(), Name: v.Name, Industrys: _industrys,
			AchievementCount: v.AchievementCount, PatentCount: v.PatentCount,
			ResearchName: v.ResearchName, LaboratoryName: v.LaboratoryName, Examine: v.Examine,
			Address: v.FormatBasic(), CreatedAt: v.CreatedAt, Area: (&model2.Area{
				Province: v.TenantProvince,
				City:     v.TenantCity,
			}).FormatBasic(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Detail 详细信息
func (c *Expert) Detail(id uint64) (*ExpertDetail, error) {
	mManageExpert := model.NewManageExpert()

	out, err := mManageExpert.Expert(id)

	if err != nil {
		return nil, err
	} else if out.ManageExpert == nil {
		return nil, errors.New("操作错误，专家信息不存在或已被删除")
	}
	_industrys := make([]*config.Industry, 0)

	for _, v := range out.GetIndustryAttribute() {
		_industrys = append(_industrys, config.GetIndustryInfo(v, "-", ">"))
	}
	out.Image.Image = out.Image.Analysis(config2.SystemConfig[config2.SysImageDomain])

	return &ExpertDetail{
		ID:           out.GetEncodeID(),
		TenantID:     out.GetEncodeTenantID(),
		ResearchID:   (&model2.Model{ID: out.ResearchID}).GetEncodeID(),
		LaboratoryID: (&model2.Model{ID: out.LaboratoryID}).GetEncodeID(),
		ManageExpert: out.ManageExpert,
		Industrys:    _industrys,
		Keywords:     out.GetKeywordAttribute(),
		Researchs:    out.GetResearchAttribute(),
	}, nil
}

// Form 数据操作
func (c *Expert) Form(params *BasicParams, other *config.IdentityForExpert) error {
	mManageExpert := model.NewManageExpert()

	if params.ID > 0 {
		mManageExpert.ID = params.ID

		isExist, err := model2.FirstField(mManageExpert.ManageExpert, []string{"id", "name", "mobile", "tenant_id", "examine_status", "created_at"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，专家信息不存在或已被删除")
		}
		if c.TenantID > 0 {
			if mManageExpert.TenantID != c.TenantID {
				return errors.New("操作错误，无权限操作")
			}
		} else {
			if mManageExpert.Mobile != params.Mobile {
				if isExist, err = params.isExist(mManageExpert.ManageExpert, model2.NewWhere("mobile", params.Mobile)); err != nil {
					return err
				} else if isExist {
					return errors.New("操作错误，当前站点下已存在相同手机号码")
				}
			}
		}
	}
	mManageExpert.TenantID = c.TenantID
	mManageExpert.Name = params.Name
	mManageExpert.ResearchID = other.ConvertResearch()
	mManageExpert.LaboratoryID = other.ConvertLaboratory()
	mManageExpert.Image.Image = params.Image
	mManageExpert.Area = model2.Area{
		Province: params.Area.Province, City: params.Area.City, District: params.Area.District, Address: params.Area.Address,
	}
	mManageExpert.Education = other.Education
	mManageExpert.School = other.School
	mManageExpert.Major = other.Major
	mManageExpert.Job = other.Job
	mManageExpert.Title = other.Title
	mManageExpert.Gender = model2.Gender{Gender: model2.GenderKind(other.Gender)}
	mManageExpert.WorkAt = utils.DataTimeToDate(other.WorkAt)
	mManageExpert.SetIndustryAttribute(params.Industrys)
	mManageExpert.SetKeywordAttribute(params.Keywords)
	mManageExpert.SetResearchAttribute(other.Researchs)
	mManageExpert.Introduce = params.Introduce

	if c.TenantID <= 0 {
		mManageExpert.TenantID = params.TenantID
	}
	_industrys := make([]string, 0)

	for _, v := range params.Industrys {
		_industrys = append(_industrys, config.GetIndustryInfo(v, "-", "-").Value)
	}
	manage := service.NewESManage(
		service.WithManageIdentity(config.TenantUserIdentityForExpert),
		service.WithManageIndustry(strings.Join(_industrys, "；")),
		service.WithManageKeyword(strings.Join(params.Keywords, "；")),
	)
	if mManageExpert.ID > 0 {
		if err := model2.Updates(mManageExpert.ManageExpert, mManageExpert.ManageExpert); err != nil {
			return err
		}
		if mManageExpert.ExamineStatus == model2.ExamineStatusForAgree {
			_ = manage.Update()
		}
		return nil
	}
	// 查询手机号码是否在当前租户下是否已经注册了
	mManageExpert.Mobile = params.Mobile
	mManageExpert.ExamineStatus = model2.ExamineStatusForAgree
	mManageExpert.ExamineRemark = "主动创建，无需审核"

	if isExist, err := params.isExist(mManageExpert.ManageExpert,
		model2.NewWhere("mobile", params.Mobile)); err != nil {
		return err
	} else if isExist {
		return errors.New("操作错误，已存在相同手机号码")
	}
	if err := model2.Create(mManageExpert.ManageExpert); err != nil {
		return err
	}
	service.WithManageID(mManageExpert.ID)(manage)
	service.WithManageTitle(params.Name)(manage)

	return manage.Create()
}

// Patent 专利信息
func (c *Expert) Patent(id uint64, title, applyName string) ([]*ExpertPatent, error) {
	mManageExpert := model.NewManageExpert()

	out, err := mManageExpert.Basic(id)

	if err != nil {
		return nil, err
	} else if out == nil || out.ID <= 0 {
		return nil, errors.New("操作错误，未找到对应的专家信息")
	}
	// 查看专利信息
	patents := make([]*model.ManageExpertPatent, 0)

	where := []*model2.ModelWhere{
		//model2.NewWhereFindInSet("p.apply_name", out.ResearchName),
		model2.NewWhereFindInSet("p.inventor", out.Name),
	}
	if title != "" {
		where = append(where, model2.NewWhereLike("p.title", title))
	}
	if applyName != "" {
		where = append(where, model2.NewWhereFindInSet("p.apply_name", applyName))
	}
	if patents, err = mManageExpert.Patents(where...); err != nil {
		return nil, err
	}
	list := make([]*ExpertPatent, 0)

	for _, v := range patents {
		list = append(list, &ExpertPatent{
			ID:                 v.GetEncodeID(),
			ManageExpertPatent: v,
			IsBind:             v.UserPatentCount > 0,
		})
	}
	return list, nil
}

// PatentBind 专利认领绑定
func (c *Expert) PatentBind(id uint64, patentIDs []uint64) error {
	mManageExpert := model.NewManageExpert()
	mManageExpert.ID = id

	isExist, err := model2.FirstField(mManageExpert.ManageExpert, []string{"id", "tenant_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，专家信息不存在或已被删除")
	} else if c.TenantID > 0 && c.TenantID != mManageExpert.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	data := make([]*model2.TechnologyPatentExpert, 0)

	for _, v := range patentIDs {
		data = append(data, &model2.TechnologyPatentExpert{
			ExpertID: mManageExpert.ID, PatentID: v,
		})
	}
	if len(data) > 0 {
		return model2.Creates(model.NewTechnologyPatentExpert().TechnologyPatentExpert, data)
	}
	return nil
}

// PatentUnbind 专利认领解绑
func (c *Expert) PatentUnbind(id uint64, patentID []uint64) error {
	mManageExpert := model.NewManageExpert()
	mManageExpert.ID = id

	isExist, err := model2.FirstField(mManageExpert.ManageExpert, []string{"id", "tenant_id"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，专家信息不存在或已被删除")
	} else if c.TenantID > 0 && c.TenantID != mManageExpert.TenantID {
		return errors.New("操作错误，无权限操作")
	}
	return model2.DeleteWhere(model.NewTechnologyPatentExpert().TechnologyPatentExpert, []*model2.ModelWhere{
		model2.NewWhere("expert_id", mManageExpert.ID),
		model2.NewWhereIn("patent_id", patentID),
	})
}

// Import 导入数据
func (c *Expert) Import(file string) error {
	excel := lib.NewExcel()
	err := excel.Import(strings.Replace(file, "/", "", 1), 1, 0)

	if err != nil {
		return err
	}
	data := excel.Analysis(&ExpertExcel{})

	rows := make([]*ExpertExcelInfo, 0, len(data))

	now := time.Now()

	for _, v := range data {
		_data := v.(*ExpertExcel)

		row := new(model2.ManageExpert)

		var count int64
		// 查询手机号码是否存在
		if err = model2.Count(row, &count, model2.NewWhere("mobile", _data.Mobile)); err != nil {
			return err
		}
		if count > 0 {
			continue
		}
		// 查询所属科研机构
		mManageResearch := model.NewManageResearch()
		mManageLaboratory := model.NewManageLaboratory()

		isExist := false

		if _data.Research != "" {
			if isExist, err = model2.FirstField(mManageResearch.ManageResearch, []string{"id"},
				model2.NewWhere("name", _data.Research)); err != nil {
				return err
			} else if !isExist {
				return errors.New("所属单位不存在")
			}
		}
		if _data.Laboratory != "" {
			if isExist, err = model2.FirstField(mManageLaboratory.ManageLaboratory, []string{"id"},
				model2.NewWhere("name", _data.Laboratory)); err != nil {
				return err
			} else if !isExist {
				return errors.New("所属实验室不存在")
			}
		}
		// 查询所属实验室

		industrys := make([]string, 0)

		if industrys, err = _data.industry(); err != nil {
			return err
		}
		row.ModelTenant = model2.ModelTenant{TenantID: _data.tenant()}
		row.ResearchID = mManageResearch.ID
		row.LaboratoryID = mManageLaboratory.ID
		row.Name = _data.Name
		row.Mobile = _data.Mobile
		row.Area = _data.area()
		row.Education = _data.Education
		row.School = _data.School
		row.Major = _data.Major
		row.Job = _data.Job
		row.Title = _data.Title
		row.Gender = model2.Gender{Gender: _data.gender()}
		row.WorkAt = utils.DataTimeToDate(_data.WorkAt)
		row.SetIndustryAttribute(industrys)
		row.SetKeywordAttribute(_data.keyword())
		row.Research = _data.ResearchWhere
		row.Introduce = _data.Introduce
		row.Examine = model2.Examine{
			ExamineStatus: model2.ExamineStatusForAgree,
			ExamineRemark: "主动上传，无需审核",
			ExamineAt:     now,
		}
		row.CreatedAt = now
		row.UpdatedAt = now
		rows = append(rows, &ExpertExcelInfo{
			ManageExpert: row,
			Tag2:         _data.Tag2,
			Tag3:         _data.Tag3,
		})
	}
	if len(rows) > 0 {
		return orm.GetDB().Transaction(func(tx *gorm.DB) error {
			//mManageExpert := model2.NewManageExpert()
			manage := service.NewESManage()

			for _, v := range rows {
				if err = model2.Create(v.ManageExpert, tx); err != nil {
					return err
				}
				enterprises := make([]*model2.ManageCooperateEnterprise, 0)
				// 已合作的企业
				if v.Tag2 != "" {
					for _, val := range strings.Split(v.Tag2, "\n") {
						enterprises = append(enterprises, &model2.ManageCooperateEnterprise{
							ModelTenant: model2.ModelTenant{TenantID: v.TenantID},
							Mode:        model2.ManageCooperateEnterpriseModeForCooperateAlready,
							Name:        val,
							ModelAt: model2.ModelAt{
								CreatedAt: now, UpdatedAt: now,
							},
						})
					}
				}
				// 想合作的企业
				if v.Tag3 != "" {
					for _, val := range strings.Split(v.Tag2, "\n") {
						enterprises = append(enterprises, &model2.ManageCooperateEnterprise{
							ModelTenant: model2.ModelTenant{TenantID: v.TenantID},
							Mode:        model2.ManageCooperateEnterpriseModeForCooperateToWant,
							Name:        val,
							ModelAt: model2.ModelAt{
								CreatedAt: now, UpdatedAt: now,
							},
						})
					}
				}
				if len(enterprises) > 0 {
					mManageCooperateEnterprise := model.NewManageCooperateEnterprise()

					if err = model2.Creates(mManageCooperateEnterprise.ManageCooperateEnterprise, &enterprises, tx); err != nil {
						return err
					}
				}
				_industrys := make([]string, 0)

				for _, val := range v.GetIndustryAttribute() {
					_industrys = append(_industrys, config.GetIndustryInfo(val, "-", "-").Value)
				}
				service.WithManageID(v.ID)(manage)
				service.WithManageTitle(v.Name)(manage)
				service.WithManageIdentity(config.TenantUserIdentityForExpert)(manage)
				service.WithManageIndustry(strings.Join(_industrys, "；"))(manage)
				service.WithManageKeyword(strings.Join(v.GetKeywordAttribute(), "；"))(manage)
			}
			if err = manage.Create(); err != nil {
				return err
			}
			return nil
		})
	}
	return nil
}

func (c *ExpertExcel) tenant() uint64 {
	return 0
}

func (c *ExpertExcel) gender() model2.GenderKind {
	if c.Gender == "男" {
		return model2.GenderKindForMale
	}
	return model2.GenderKindForFemale
}

func (c *ExpertExcel) area() model2.Area {
	area := model2.Area{
		Address: c.Address,
	}

	filter := func(key, value string) string {
		areaInfo, has := config.MemoryForAreaInfo[key]

		if !has {
			return ""
		}
		if value == "" {
			return ""
		}
		for k, v := range areaInfo {
			if v == value {
				return k
			}
		}
		return ""
	}
	// 省
	area.Province = filter(config2.DefaultChinaAreaCode, c.Province)

	if area.Province != "" {
		area.City = filter(area.Province, c.City)

		if area.City != "" {
			area.District = filter(area.District, c.City)
		}
	}
	return area
}

func (c *ExpertExcel) industry() ([]string, error) {
	// 存在多个
	industrys := strings.Split(c.Industry, "\n")

	out := make([]string, 0)

	for _, v := range industrys {
		_industrys := strings.Split(v, "/")

		_out := make([]string, 0, len(_industrys))

		for key, industry := range _industrys {
			mSysIndustry := model.NewSysIndustry()

			isExist, err := model2.FirstField(mSysIndustry.SysIndustry, []string{"id"}, model2.NewWhere("name", industry))

			if err != nil {
				return nil, err
			}
			if !isExist {
				if key > 0 {
					mSysIndustry.ParentID = utils.StringToUnit64(_out[key-1])
				}
				mSysIndustry.Name = industry

				if err = model2.Create(mSysIndustry.SysIndustry); err != nil {
					return nil, err
				}
			} else {
				_out = append(_out, fmt.Sprintf("%d", mSysIndustry.ID))
			}
			out = append(out, strings.Join(_out, "-"))
		}
	}
	return out, nil
}

func (c *ExpertExcel) keyword() []string {
	return strings.Split(c.Keyword, "\n")
}

func NewExpert() ExpertHandle {
	return func(session *session.Admin) *Expert {
		return &Expert{session}
	}
}