package technology

import (
	"SciencesServer/app/api/enterprise/model"
	"SciencesServer/app/basic/config"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/app/session"
	"errors"
	"strings"
	"time"
)

// Achievement 成果信息
type Achievement struct {
	*session.Enterprise
	tenantID uint64
}

type AchievementHandle func(session *session.Enterprise, tenantID uint64) *Achievement

type (
	// AchievementInfo 成果信息
	AchievementInfo struct {
		ID string `json:"id"`
		*model.TechnologyAchievementInfo
		Industrys []string `json:"industrys"`
	}
	// AchievementMatchInfo 成果匹配信息
	AchievementMatchInfo struct {
		ID string `json:"id"`
		*model.TechnologyAchievementInstance
		Industrys []string `json:"industrys"`
		Keywords  []string `json:"keywords"`
		Customers []string `json:"customers"`
	}
	// AchievementDetail 成果详情
	AchievementDetail struct {
		ID string `json:"id"`
		*model2.TechnologyAchievement
		Customers []string `json:"customers"`
		Keywords  []string `json:"keywords"`
	}
	// AchievementParams 成果参数信息
	AchievementParams struct {
		ID                                            uint64
		Title, Image, File, Introduce, Description    string
		Mode, Maturity, LeadStandard, CooperationMode int      // 技术成熟度 领先标准 合作模式
		Industrys, Customers, Keywords                []string // 所属客户 关键词
		IsSubmit                                      int      //  是否提交审核
	}
)

// Instance 基本信息
func (c *Achievement) Instance(status, page, pageSize int) (*controller.ReturnPages, error) {
	mTechnologyAchievement := model.NewTechnologyAchievement()

	where := []*model2.ModelWhere{model2.NewWhere("a.status", status)}

	var count int64

	out, err := mTechnologyAchievement.Achievement(page, pageSize, &count, where...)

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

	for _, v := range out {
		mTechnologyAchievement.Introduce = v.Industry

		list = append(list, &AchievementInfo{
			ID:                        v.GetEncodeID(),
			TechnologyAchievementInfo: v,
			Industrys:                 mTechnologyAchievement.GetIndustryAttribute(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Match 匹配信息
func (c *Achievement) Match(title string, industrys, keywords []string) (*controller.ReturnPages, error) {
	params := strings.Join([]string{
		title, strings.Join(industrys, ","), strings.Join(keywords, ","),
	}, ",")
	achievement := service.NewESAchievement(
		service.WithAchievementTitle(params),
		service.WithAchievementIndustry(params),
		service.WithAchievementKeyword(params),
	)
	out, count, err := achievement.Search(0, 0)

	if err != nil {
		return nil, err
	}
	ids := make([]uint64, 0)

	for _, v := range out.([]interface{}) {
		val := v.(*service.ESAchievement)
		ids = append(ids, val.ID)
	}
	achievements := make([]*model.TechnologyAchievementInstance, 0)

	mTechnologyAchievement := model.NewTechnologyAchievement()

	if achievements, err = mTechnologyAchievement.Instance(model2.NewWhereIn("a.id", ids),
		model2.NewWhere("a.shelf_status", model2.ShelfStatusForUp)); err != nil {
		return nil, err
	}
	list := make([]*AchievementMatchInfo, 0)

	for _, v := range achievements {
		mTechnologyAchievement.Industry = v.Industry
		mTechnologyAchievement.Keyword = v.Keyword
		mTechnologyAchievement.Customer = v.Customer

		list = append(list, &AchievementMatchInfo{
			ID:                            v.GetEncodeID(),
			TechnologyAchievementInstance: v,
			Industrys:                     mTechnologyAchievement.GetIndustryAttribute(),
			Keywords:                      mTechnologyAchievement.GetKeywordAttribute(),
			Customers:                     mTechnologyAchievement.GetCustomerAttribute(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Detail 详情信息
func (c *Achievement) Detail(id uint64) (*AchievementDetail, error) {
	mTechnologyAchievement := model.NewTechnologyAchievement()
	mTechnologyAchievement.ID = id

	isExist, err := model2.First(mTechnologyAchievement.TechnologyAchievement)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, errors.New("操作错误，成果信息不存在或已被删除")
	}
	return &AchievementDetail{
		ID:                    mTechnologyAchievement.GetEncodeID(),
		TechnologyAchievement: mTechnologyAchievement.TechnologyAchievement,
		Customers:             mTechnologyAchievement.GetCustomerAttribute(),
		Keywords:              mTechnologyAchievement.GetKeywordAttribute(),
	}, nil
}

// Form 数据操作
func (c *Achievement) Form(params *AchievementParams) error {
	mTechnologyAchievement := model.NewTechnologyAchievement()

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

		isExist, err := model2.FirstField(mTechnologyAchievement.TechnologyAchievement, []string{"id", "uid", "status", "created_at", "updated_at"})

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，成果信息不存在或已被删除")
		} else if mTechnologyAchievement.UID != c.UID {
			return errors.New("无权限操作")
		} else if mTechnologyAchievement.Status != model2.TechnologyStatusKindForRefuse &&
			mTechnologyAchievement.Status != model2.TechnologyStatusKindForDraft {
			return errors.New("操作错误，当前状态不允许修改")
		}
	}
	mTechnologyAchievement.Mode = model2.TechnologyAchievementMode(params.Mode)
	mTechnologyAchievement.Title = params.Title
	mTechnologyAchievement.Image.Image = params.Image
	mTechnologyAchievement.File = params.File
	mTechnologyAchievement.SetIndustryAttribute(params.Industrys)
	mTechnologyAchievement.SetCustomerAttribute(params.Customers)
	mTechnologyAchievement.Maturity = config.TechnologyMaturity(params.Maturity)
	mTechnologyAchievement.LeadStandard = model2.TechnologyProductLeadStandard(params.LeadStandard)
	mTechnologyAchievement.CooperationMode = config.TechnologyCooperationMode(params.CooperationMode)
	mTechnologyAchievement.SetKeywordAttribute(params.Keywords)
	mTechnologyAchievement.Introduce = params.Introduce
	mTechnologyAchievement.Description = params.Description

	if mTechnologyAchievement.ID > 0 {
		mTechnologyAchievement.Status = model2.TechnologyStatusKindForExamining
		return model2.Updates(mTechnologyAchievement.TechnologyAchievement, mTechnologyAchievement.TechnologyAchievement)
	}
	mTechnologyAchievement.TenantID = c.tenantID
	mTechnologyAchievement.UID = c.UID

	if params.IsSubmit > 0 {
		mTechnologyAchievement.Status = model2.TechnologyStatusKindForExamining
	}
	return model2.Create(mTechnologyAchievement.TechnologyAchievement)
}

// Shelf 上下架
func (c *Achievement) Shelf(id uint64, status int) error {
	mTechnologyAchievement := model.NewTechnologyAchievement()
	mTechnologyAchievement.ID = id

	isExist, err := model2.FirstField(mTechnologyAchievement.TechnologyAchievement, []string{"id", "uid", "shelf_status", "status"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，成果信息不存在或已被删除")
	} else if mTechnologyAchievement.UID != c.UID {
		return errors.New("无权限操作")
	} else if mTechnologyAchievement.ShelfStatus == model2.ShelfStatusKind(status) {
		return errors.New("操作错误，无需变更上下架状态")
	}

	if err = model2.Updates(mTechnologyAchievement.TechnologyAchievement, map[string]interface{}{
		"shelf_status": status, "updated_at": time.Now(),
	}); err != nil {
		return err
	}
	manage := service.NewESAchievement(
		service.WithAchievementID(mTechnologyAchievement.ID),
		service.WithAchievementShow(status),
	)
	return manage.Update()
}

// Delete 删除操作
func (c *Achievement) Delete(id uint64) error {
	mTechnologyAchievement := model.NewTechnologyAchievement()
	mTechnologyAchievement.ID = id

	isExist, err := model2.FirstField(mTechnologyAchievement.TechnologyAchievement, []string{"id", "uid"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，成就信息不存在或已被删除")
	} else if mTechnologyAchievement.UID != c.UID {
		return errors.New("无权限操作")
	}

	if err = model2.Delete(mTechnologyAchievement.TechnologyAchievement); err != nil {
		return err
	}
	manage := service.NewESAchievement(
		service.WithAchievementID(mTechnologyAchievement.ID),
	)
	return manage.Delete()
}

func NewAchievement() AchievementHandle {
	return func(session *session.Enterprise, tenantID uint64) *Achievement {
		return &Achievement{
			Enterprise: session,
			tenantID:   tenantID,
		}
	}
}