package budget

import (
	"zhiyuan/pkg/db"
)

type Control struct {
	Type  string                 `json:"type"`
	Value interface{}            `json:"value"`
	Param map[string]interface{} `json:"param"`
	Event map[string]string      `json:"event"`
	Last  bool                   `json:"last"`
}

func (control *Control) PraseForArgs(args ...interface{}) {
	if len(args) > 0 {
		control.Type = db.ToString(args[0])
	}

	if len(args) > 1 {
		control.Value = args[1]
	}

	if len(args) > 2 {
		if p, ok := args[2].(map[string]interface{}); ok {
			control.Param = p
		} else {
			control.Param = make(map[string]interface{})
		}
	} else {
		control.Param = make(map[string]interface{})
	}

	if len(args) > 3 {
		if event, ok := args[3].(map[string]string); ok {
			control.Event = event
		} else {
			control.Event = make(map[string]string)
			if event, ok := args[3].(map[string]interface{}); ok {
				for key, val := range event {
					control.Event[key] = db.ToString(val)
				}
			}
		}
	} else {
		control.Event = make(map[string]string)
	}

	control.Last = true
	if len(args) > 4 {
		if p, ok := args[4].(bool); ok {
			control.Last = p
		}
	}
}

func (control *Control) PraseForMap(value map[string]interface{}) {
	control.Type = db.ToString(value["type"])
	control.Value = value["value"]
	if param, ok := value["param"].(map[string]interface{}); ok {
		control.Param = param
	} else {
		control.Param = make(map[string]interface{})
	}
	if event, ok := value["event"].(map[string]string); ok {
		control.Event = event
	} else {
		control.Event = make(map[string]string)
		if event, ok := value["event"].(map[string]interface{}); ok {
			for key, val := range event {
				control.Event[key] = db.ToString(val)
			}
		}
	}
	control.Last = db.ToBool(value["last"])
}

func (control *Control) ToMap() map[string]interface{} {
	return map[string]interface{}{
		"type":  control.Type,
		"value": control.Value,
		"param": control.Param,
		"event": control.Event,
		"last":  control.Last,
	}
}

func (control *Control) Handle(typ string, value interface{}, prop *PropForm, context *Context) error {
	switch control.Type {
	case "group", "popover":
		if v, ok := value.(map[string]interface{}); ok {
			index, _ := db.ToInt64(v["index"])
			value := v["value"]
			controls := make([]interface{}, 0)
			if s, ok := control.Param["controls"].([]interface{}); ok {
				controls = s
			}
			if _, ok := prop.Result.([]interface{}); !ok {
				prop.Result = make([]interface{}, len(controls))
			}
			if result, ok := prop.Result.([]interface{}); ok {
				if len(result) < len(controls) {
					prop.Result = append(result, make([]interface{}, len(controls)-len(result)))
				}
			}
			if index < int64(len(controls)) {
				var control Control
				if c, ok := controls[index].(Control); ok {
					control = c
				} else if c, ok := controls[index].(*Control); ok {
					control = *c
				} else if c, ok := controls[index].(map[string]interface{}); ok {
					control.PraseForMap(c)
				}
				if result, ok := prop.Result.([]interface{}); ok {
					props := new(PropForm)
					props.Key = context.Order.NewPropKey()
					props.Instance = prop.Instance
					props.Control = &control
					props.Result = result[index]
					props.AddUseKey(0)
					control.Handle(typ, value, props, context)
					result[index] = props.Result
					prop.Result = result
				}

			}

		}
	default:
		switch typ {
		case "input":
			prop.Result = value
		}
	}

	context.ModifyAfter(prop.Key)

	if event, ok := control.Event[typ]; ok {
		_, err := context.Exec(event)
		if err != nil {
			return err
		}
	}
	return nil
}