package domain

import "fmt"

var (
	SchemaTable     TableType = "Schema"         // 方案
	SubProcessTable TableType = "SubProcess"     // 子过程
	CalculateItem   TableType = "CalculateItem"  // 计算项
	CalculateTable  TableType = "CalculateTable" // 计算表
	CalculateSet    TableType = "CalculateSet"   // 计算集
)

var (
	FlagGroup = "Group"
	FlagSet   = "Set"
)

var (
	TableSplit   SelectExprType = "TableSplit"   //拆分
	SplitAssign  SelectExprType = "SplitAssign"  //拆分赋值
	NormalAssign SelectExprType = "NormalAssign" //正常赋值
)

type SelectExprType string

type QueryComponent struct {
	Id          string               `json:"id"`
	MasterTable *QueryComponentTable `json:"masterTable"`
	Conditions  []ConditionExpr      `json:"conditions"`
	Selects     []SelectExprGroup    `json:"selects"`
	Description string               `json:"description"`
	Formula     *FieldFormulaExpr    `json:"formula"`
	Aggregation *AggregationRule     `json:"aggregation"`
}

func (qc QueryComponent) AllSelectExpr() []SelectExpr {
	var res = make([]SelectExpr, 0)
	for _, s := range qc.Selects {
		res = append(res, s.SelectExpr)
		if len(s.SubSelects) > 0 {
			res = append(res, s.SubSelects...)
		}
	}
	return res
}

type ConditionExpr struct { // 条件表达式
	Id             string    `json:"id"`
	FieldLeft      FieldExpr `json:"fieldLeft"`
	FieldRight     FieldExpr `json:"fieldRight"`
	OperatorSymbol string    `json:"operatorSymbol"`
	AndOr          string    `json:"andOr"` // and or
}

func (c ConditionExpr) Equal(compare ConditionExpr) bool {
	return c.OperatorSymbol == compare.OperatorSymbol &&
		c.FieldLeft.ExprSql == compare.FieldLeft.ExprSql &&
		c.FieldRight.ExprSql == compare.FieldRight.ExprSql
}

func (c ConditionExpr) ExprHuman() string {
	return c.FieldLeft.ExprHuman + c.OperatorSymbol + c.FieldRight.ExprHuman
}

type FieldFormulaExpr struct {
	FieldExpr
}

type SelectExpr struct { // 查询表达式
	Id         string    `json:"id"`
	FieldLeft  FieldExpr `json:"fieldLeft"`
	FieldRight FieldExpr `json:"fieldRight"` // has value when type is equal to 1
	Type       string    `json:"type"`       // 1.拆分 2.拆方赋值 3.正常赋值
	//SubGroup    []SelectExpr `json:"subGroup,omitempty"`
}

func (s SelectExpr) Equal(compare SelectExpr) bool {
	return s.FieldLeft.ExprSql == compare.FieldLeft.ExprSql &&
		s.FieldRight.ExprSql == compare.FieldRight.ExprSql
}

func (c SelectExpr) ExprHuman() string {
	return c.FieldLeft.ExprHuman + "=" + c.FieldRight.ExprHuman
}

type SelectExprGroup struct { // 查询表达式
	SelectExpr
	SubSelects []SelectExpr `json:"subSelects,omitempty"`
}

type FieldExpr struct {
	//LabelColumns []LabelColumn `json:"labelColumns"`
	TableFields []TableField `json:"tableFields"`
	ExprHuman   string       `json:"exprHuman"`
	ExprSql     string       `json:"exprSql"`
}

type LabelColumn struct {
	Column    TableField `json:"column,omitempty"`
	LabelExpr string     `json:"labelExpr"`
}

type TableField struct {
	TableId      int    `json:"tableId"`
	TableName    string `json:"tableName"`
	TableSqlName string `json:"tableSqlName"`
	FieldName    string `json:"fieldName"`
	FieldSqlName string `json:"fieldSqlName"`
	FieldSQLType string `json:"fieldSqlType"`
}

func (f TableField) String() string {
	return fmt.Sprintf("%s.%s", f.TableSqlName, f.FieldSqlName)
}

type QueryComponentTable struct {
	// 表Id
	TableId int `json:"tableId"`
	// 表类型 MainTable:主表 SideTable:副表 SubTable:分表  ExcelTable:Excel表
	TableType string `json:"tableType"`
	// 名称
	Name string `json:"name"`
	// 对应数据库名称
	SQLName string `json:"sqlName"`
	// 父级ID
	ParentId int `json:"parentId"`
	// 所有列
	Fields []*Field `json:"fields"`
}

type Join struct {
	TableId      int
	TableName    string
	TableSqlName string
	Conditions   []ConditionExpr
	On           SelectExpr
}

func NewQueryComponentTable(t *Table) *QueryComponentTable {
	return &QueryComponentTable{
		TableId:   t.TableId,
		TableType: t.TableType,
		Name:      t.Name,
		SQLName:   t.SQLName,
		ParentId:  t.ParentId,
		Fields:    t.Fields(false),
	}
}

func QueryComponentsToMapById(items []*QueryComponent) map[string]*QueryComponent {
	var res = make(map[string]*QueryComponent)
	for i := range items {
		res[items[i].Id] = items[i]
	}
	return res
}

func ConditionsToMapById(items []ConditionExpr) map[string]ConditionExpr {
	var res = make(map[string]ConditionExpr)
	for i := range items {
		res[items[i].Id] = items[i]
	}
	return res
}

func SelectsToMapById(items []SelectExprGroup) map[string]SelectExprGroup {
	var res = make(map[string]SelectExprGroup)
	for i := range items {
		res[items[i].Id] = items[i]
	}
	return res
}

func SelectsExprToMapById(items []SelectExpr) map[string]SelectExpr {
	var res = make(map[string]SelectExpr)
	for i := range items {
		res[items[i].Id] = items[i]
	}
	return res
}