package controller

import (
	"SciencesServer/app/api/website/model"
	config2 "SciencesServer/app/basic/config"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/config"
	"SciencesServer/utils"
	"strings"
)

type Index struct {
	*service.Session
}

type IndexHandle func(session *service.Session) *Index

type (
	// InstanceInfo 首页信息
	InstanceInfo struct {
		*InstanceStaticInfo
		Distribution *InstanceDistributionInfo `json:"distribution"`
	}
	// InstanceStaticInfo 统计信息
	InstanceStaticInfo struct {
		ExpertCount      int64 `json:"expert_count"`      // 专家数量
		CompanyCount     int64 `json:"company_count"`     // 公司数量
		PatentCount      int64 `json:"patent_count"`      // 专利数量
		AchievementCount int64 `json:"achievement_count"` // 成果数量
		DemandCount      int64 `json:"demand_count"`      // 需求数量
		DockingCount     int64 `json:"docking_count"`     // 对接数量
	}
	// InstanceDistributionInfo 分布信息
	InstanceDistributionInfo struct {
		Expert      map[string]*InstanceDistributionDetailInfo `json:"expert"`      // 专家信息
		Laboratory  map[string]*InstanceDistributionDetailInfo `json:"laboratory"`  // 公司信息
		Demand      map[string]*InstanceDistributionDetailInfo `json:"demand"`      // 专利信息
		Patent      map[string]*InstanceDistributionDetailInfo `json:"patent"`      // 成果信息
		Achievement map[string]*InstanceDistributionDetailInfo `json:"achievement"` // 需求信息
	}
	// InstanceDistributionDetailInfo 分布区域信息
	InstanceDistributionDetailInfo struct {
		Code     string                                     `json:"code"`     // 区域编码
		Name     string                                     `json:"name"`     // 区域名称
		Count    int                                        `json:"count"`    // 数量
		Industry map[string]int                             `json:"industry"` // 行业领域
		Children map[string]*InstanceDistributionDetailInfo `json:"children"` // 子集信息
	}
)

// industry 所属行业信息
func (c *Index) industry(src, sep string) map[string]int {
	values := strings.Split(src, sep)

	out := make(map[string]int, 0)

	for _, value := range values {
		_values := make([]string, 0)
		_ = utils.FromJSON(value, &_values)

		for _, v := range _values {
			if _, has := out[v]; has {
				out[v]++
				continue
			}
			out[v] = 1
		}
	}
	return out
}

// distribution 分布统计
func (c *Index) distribution(src []*model.DataAreaDistributionInfo) map[string]*InstanceDistributionDetailInfo {
	out := make(map[string]*InstanceDistributionDetailInfo, 0)

	for _, v := range src {
		industrys := c.industry(v.Industry, "&")

		_, has := out[v.Province]

		if !has {
			out[v.Province] = &InstanceDistributionDetailInfo{
				Code:     v.Province,
				Name:     config2.MemoryForAreaInfo[config.DefaultChinaAreaCode][v.Province],
				Industry: make(map[string]int, 0),
				Count:    105,
				Children: make(map[string]*InstanceDistributionDetailInfo, 0),
			}
			goto NEXT1
		}
		out[v.Province].Count++
	NEXT1:
		if v.City != "" {
			if _, has = out[v.Province].Children[v.City]; !has {
				out[v.Province].Children[v.City] = &InstanceDistributionDetailInfo{
					Code:     v.City,
					Count:    105,
					Name:     config2.MemoryForAreaInfo[v.Province][v.City],
					Industry: make(map[string]int, 0),
					Children: make(map[string]*InstanceDistributionDetailInfo, 0),
				}
				goto NEXT2
			}
			out[v.Province].Children[v.City].Count++
		} else {
			out[v.Province].Industry = industrys
		}
	NEXT2:
		if v.District != "" {
			if _, has = out[v.Province].Children[v.City].Children[v.District]; !has {
				out[v.Province].Children[v.City].Children[v.District] = &InstanceDistributionDetailInfo{
					Code:     v.District,
					Count:    105,
					Name:     config2.MemoryForAreaInfo[v.City][v.District],
					Industry: industrys,
				}
				continue
			}
			out[v.Province].Children[v.City].Children[v.District].Count++
		} else {
			out[v.Province].Children[v.City].Industry = industrys
		}
	}
	return out
}

func (c *Index) filterIndustry(src *InstanceDistributionDetailInfo, out map[string]int) {
	if len(src.Children) > 0 {
		for _, v := range src.Children {
			for key, val := range v.Industry {
				if _, has := out[key]; !has {
					out[key] = val
					continue
				}
				out[key] += val
			}
			c.filterIndustry(v, out)
		}
	}
}

func (c *Index) filter(src map[string]*InstanceDistributionDetailInfo) {
	for _, v := range src {
		c.filterIndustry(v, v.Industry)
		c.filter(v.Children)
	}
}

// static 数量统计
func (c *Index) static() (*InstanceStaticInfo, error) {
	out := new(InstanceStaticInfo)
	var err error
	// 专家信息
	mManageExpert := model.NewManageExpert()

	if err = model2.Count(mManageExpert.ManageExpert, &out.ExpertCount, model2.NewWhere("examine_status", model2.ExamineStatusForAgree)); err != nil {
		return nil, err
	}
	// 专利信息
	mSysPatent := model.NewSysPatent()

	if err = model2.Count(mSysPatent.SysPatent, &out.PatentCount, model2.NewWhere("shelf_status", model2.ShelfStatusForUp)); err != nil {
		return nil, err
	}
	//成果信息
	mTechnologyAchievement := model.NewTechnologyAchievement()

	if err = model2.Count(mTechnologyAchievement.TechnologyAchievement, &out.AchievementCount, model2.NewWhere("shelf_status", model2.ShelfStatusForUp),
		model2.NewWhere("status", model2.TechnologyAchievementStatusForAgree)); err != nil {
		return nil, err
	}

	// 公司信息
	mManageCompany := model.NewManageCompany()

	if err = model2.Count(mManageCompany.ManageCompany, &out.CompanyCount, model2.NewWhere("examine_status", model2.ExamineStatusForAgree)); err != nil {
		return nil, err
	}
	// 需求信息
	mTechnologyDemand := model.NewTechnologyDemand()

	if err = model2.Count(mTechnologyDemand.TechnologyDemand, &out.DemandCount,
		model2.NewWhere("status", model2.TechnologyDemandStatusForAgree)); err != nil {
		return nil, err
	}
	// 对接信息
	mServiceDocking := model.NewServiceDocking()

	if err = model2.Count(mServiceDocking.ServiceDocking, &out.DockingCount); err != nil {
		return nil, err
	}
	return out, nil
}

// DistributionExpert 专家分布
func (c *Index) DistributionExpert(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
	mManageExpert := model.NewManageExpert()
	out, err := mManageExpert.Distribution(province, city)

	if err != nil {
		return nil, err
	}
	_out := c.distribution(out)
	c.filter(_out)
	_out["500000"] = &InstanceDistributionDetailInfo{
		Code:     "500000",
		Name:     "重庆",
		Count:    300,
		Industry: nil,
		Children: map[string]*InstanceDistributionDetailInfo{
			"500100": &InstanceDistributionDetailInfo{
				Code:     "500100",
				Name:     "市辖区",
				Count:    300,
				Industry: nil,
				Children: nil,
			},
		},
	}

	return _out, nil
}

// DistributionLaboratory 实验室分布
func (c *Index) DistributionLaboratory(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
	mManageLaboratory := model.NewManageLaboratory()
	out, err := mManageLaboratory.Distribution()

	if err != nil {
		return nil, err
	}
	_out := c.distribution(out)
	c.filter(_out)

	return _out, nil
}

// DistributionDemand 需求信息
func (c *Index) DistributionDemand(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
	mTechnologyDemand := model.NewTechnologyDemand()
	out, err := mTechnologyDemand.Distribution()

	if err != nil {
		return nil, err
	}
	_out := c.distribution(out)
	c.filter(_out)

	return _out, nil
}

// DistributionPatent 专利信息
func (c *Index) DistributionPatent(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
	mSysPatent := model.NewSysPatent()
	out, err := mSysPatent.Distribution()

	if err != nil {
		return nil, err
	}
	_out := c.distribution(out)
	c.filter(_out)

	return _out, nil
}

// DistributionAchievement 技术成果信息
func (c *Index) DistributionAchievement(province, city string) (map[string]*InstanceDistributionDetailInfo, error) {
	mTechnologyAchievement := model.NewTechnologyAchievement()
	out, err := mTechnologyAchievement.Distribution()

	if err != nil {
		return nil, err
	}
	_out := c.distribution(out)
	c.filter(_out)

	return _out, nil
}

// Instance 首页信息
func (c *Index) Instance() (*InstanceInfo, error) {
	out := &InstanceInfo{
		InstanceStaticInfo: new(InstanceStaticInfo),
		Distribution:       new(InstanceDistributionInfo),
	}
	var err error
	// 数量统计信息
	if out.InstanceStaticInfo, err = c.static(); err != nil {
		return nil, err
	}
	return out, nil
}

func NewIndex() IndexHandle {
	return func(session *service.Session) *Index {
		return &Index{
			Session: session,
		}
	}
}