package manage

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

// Company 公司信息
type Company struct {
	*session.Enterprise
}

type CompanyHandle func(session *session.Enterprise) *Company

type (
	// CompanyDetail 详细信息
	CompanyDetail struct {
		ID string `json:"id"`
		*model2.ManageCompany
		Keywords []string `json:"keywords"`
	}
	// CompanyProductInfo 公司产品信息
	CompanyProductInfo struct {
		ID string `json:"id"`
		*model.TechnologyProductInfo
		Industrys []string `json:"industrys"`
		Keywords  []string `json:"keywords"`
	}
	// CompanyMatchInfo 公司匹配信息
	CompanyMatchInfo struct {
		ID       string                   `json:"id"`
		Kind     model2.ManageCompanyKind `json:"kind"`
		Name     string                   `json:"name"`
		Image    string                   `json:"image"`
		Product  string                   `json:"product"`
		Url      string                   `json:"url"`
		Keywords []string                 `json:"keywords"`
	}
)

// Detail 详细信息
func (c *Company) Detail(id uint64) (*CompanyDetail, error) {
	mManageCompany := model.NewManageCompany()
	mManageCompany.ID = id

	isExist, err := model2.First(mManageCompany.ManageCompany)

	if err != nil {
		return nil, err
	} else if !isExist {
		return nil, errors.New("操作错误，企业信息不存在或已被删除")
	}
	return &CompanyDetail{
		ID:            mManageCompany.GetEncodeID(),
		ManageCompany: mManageCompany.ManageCompany,
		Keywords:      mManageCompany.GetKeywordAttribute(),
	}, nil
}

// Product 产品信息
func (c *Company) Product(id uint64, page, pageSize int) ([]*CompanyProductInfo, error) {
	mUserCompany := model.NewUserCompany()

	uids := make([]uint64, 0)

	// 查询公司下所有的用户信息
	err := model2.Pluck(mUserCompany.UserCompany, "uid", &uids, model2.NewWhere("company_id", id),
		model2.NewWhere("invalid_status", model2.InvalidStatusForNot))

	if err != nil {
		return nil, err
	}
	mTechnologyProduct := model.NewTechnologyProduct()

	var count int64

	out := make([]*model.TechnologyProductInfo, 0)

	if out, err = mTechnologyProduct.Product(page, pageSize, &count, model2.NewWhereIn("uid", uids)); err != nil {
		return nil, err
	}
	list := make([]*CompanyProductInfo, 0)

	for _, v := range out {
		mTechnologyProduct.Industry = v.Industry
		mTechnologyProduct.Keyword = v.Keyword

		list = append(list, &CompanyProductInfo{
			ID:                    v.GetEncodeID(),
			TechnologyProductInfo: v,
			Industrys:             mTechnologyProduct.GetIndustryAttribute(),
			Keywords:              mTechnologyProduct.GetKeywordAttribute(),
		})
	}
	return list, nil
}

// Match 匹配信息
func (c *Company) Match(title string, industrys, keywords []string) ([]*CompanyMatchInfo, error) {
	params := strings.Join([]string{
		title, strings.Join(industrys, ","), strings.Join(keywords, ","),
	}, ",")
	manage := service.NewESManage(
		service.WithManageIdentity(config.TenantUserIdentityForCompany),
	)
	out, err := manage.Search(0, 0, map[string]interface{}{
		"title": params, "industry": params, "keyword": params, "research": params,
	})
	if err != nil {
		return nil, err
	}
	ids := make([]uint64, 0)

	for _, v := range out.([]interface{}) {
		val := v.(*service.ESManage)
		ids = append(ids, val.ID)
	}
	mManageCompany := model.NewManageCompany()

	companys := make([]*model2.ManageCompany, 0)

	if err := model2.ScanFields(mManageCompany.ManageCompany, &companys, []string{"id", "kind", "name", "image", "url", "keyword"},
		&model2.ModelWhereOrder{
			Where: model2.NewWhereIn("id", ids),
			Order: model2.NewOrder("id", model2.OrderModeToDesc),
		}, &model2.ModelWhereOrder{
			Where: model2.NewWhere("examine_status", model2.ExamineStatusForAgree),
		}); err != nil {
		return nil, err
	}

	list := make([]*CompanyMatchInfo, 0)

	for _, v := range companys {
		list = append(list, &CompanyMatchInfo{
			ID: v.GetEncodeID(), Kind: v.Kind, Name: v.Name,
			Image:    v.Image.Analysis(config2.SettingInfo.Domain),
			Url:      v.Url,
			Keywords: v.GetKeywordAttribute(),
		})
	}
	return list, nil
}

func NewCompany() CompanyHandle {
	return func(session *session.Enterprise) *Company {
		return &Company{
			Enterprise: session,
		}
	}
}