package main

// 数据复杂分组测试

func main() {
	// 分组策略列表
	policies := []GroupPolicy{
		{Area, Group},
		{Company, Hash},
		{Title, Group},
	}
	// 待分组数据记录列表
	items := []RecordItem{
		{Area: "", Company: "", Title: "", IsLeader: ""},
		{Area: "", Company: "", Title: "", IsLeader: ""},
	}
	// 根级，外面再加一层是为了适配下面的循环处理
	rootClusters := FilterClusters{
		{Seq: 0, Items: items},
	}
	// 循环变量
	clusters := rootClusters
	for _, policy := range policies {
		// 依次按照分组策略处理
		clusters = clusters.filter(policy)
		if nil == clusters || len(clusters) == 0 {
			return
		}
	}
	if len(clusters) == 0 {
		return
	}

	// 获得平铺的叶子节点
	var results []RecordItem
	for _, cluster := range clusters {
		if nil == cluster.Items || len(cluster.Items) == 0 {
			continue
		}

		results = append(results, cluster.Items...)
	}
	if nil == results || len(results) == 0 {
		return
	}

	// 求箱子数量
	length := len(results)
	groupSize := 50
	groupCount := length / groupSize
	if length%groupSize > 0 {
		groupCount++
	}

	// TODO 最后把results塞进箱子里就是
}

type RecordItem map[string]string // 数据记录
// 聚类，多叉树形结构
type FilterCluster struct {
	Seq         int            // 序号
	Items       []RecordItem   // 组内记录列表
	SubClusters FilterClusters // 子级聚类集合
}
type FilterClusters []FilterCluster // 聚类集合

// 分组策略字段
const (
	Area     = "area"
	Company  = "company"
	Title    = "title"
	IsLeader = "isLeader"
)

// 分组策略类型
type FilterType int8

const (
	Random FilterType = iota // 随机
	Group                    // 聚合
	Hash                     // 散列
)

// 分组策略
type GroupPolicy struct {
	Name string
	Type FilterType
}

// 策略模式，分支处理，返回当前聚类集合再进一步处理的子级聚类集合
func (clusters *FilterClusters) filter(policy GroupPolicy) FilterClusters {
	if policy.Type == Random {
		return clusters.mapping(policy.Name, random)
	} else if policy.Type == Group {
		return clusters.mapping(policy.Name, group)
	} else if policy.Type == Hash {
		return clusters.mapping(policy.Name, hash)
	}
	return nil
}

// 将子级聚类集合映射关联到父级，如此，虽然仅返回子级聚类集合，但通过根级对象可以遍历整棵树
func (clusters *FilterClusters) mapping(name string, fn func(string, FilterCluster) FilterClusters) FilterClusters {
	var allSubClusters FilterClusters
	for i := 0; i < len(*clusters); i++ {
		subClusters := fn(name, (*clusters)[i])
		if nil == subClusters || len(subClusters) == 0 {
			continue
		}
		(*clusters)[i].SubClusters = subClusters
		allSubClusters = append(allSubClusters, subClusters...)
	}
	if nil == allSubClusters || len(allSubClusters) == 0 {
		return nil
	}
	return allSubClusters
}

// TODO 随机算法实现
func random(name string, cluster FilterCluster) FilterClusters {
	// 建议子级聚类数量 = 当前聚类中数据记录内，指定name字段的取值数
	// 记录随机排列即可
	return nil
}

// TODO 聚合算法实现
func group(name string, cluster FilterCluster) FilterClusters {
	// 建议子级聚类数量 = 当前聚类中数据记录内，指定name字段的取值数
	// 简单近似处理，group by即可
	// 求最优解处理，建议多次迭代的kmeans
	return nil
}

// TODO 散列算法实现
func hash(name string, cluster FilterCluster) FilterClusters {
	// 建议子级聚类数量 = 当前聚类中数据记录内，指定name字段的取值数
	// 简单近似处理，写个循环分布一下数据即可
	// 求最优解处理，建议多次迭代的kmeans
	return nil
}