package gocmdDaemon

import (
	"flag"
	"fmt"

	"encoding/json"
)

type MFlag struct {
	flags      map[string]interface{}
	RemainArgs []string
}

func (m *MFlag) Int(short string, long string, value int, usage string) {
	var v int
	m.flags[long] = &v
	flag.IntVar(&v, short, value, usage)
	flag.IntVar(&v, long, value, usage)
}

func (m *MFlag) String(short string, long string, value string, usage string) {
	var v string
	m.flags[long] = &v
	flag.StringVar(&v, short, value, usage)
	flag.StringVar(&v, long, value, usage)
}

func (m *MFlag) Bool(short string, long string, value bool, usage string) {
	var v bool
	m.flags[long] = &v
	flag.BoolVar(&v, short, value, usage)
	flag.BoolVar(&v, long, value, usage)
}

func (m *MFlag) Parse() {
	flag.Parse()
	m.RemainArgs = flag.Args()
}

func (m *MFlag) GetIntFlag(name string) int {
	v, ok := m.flags[name]
	if !ok {
		return -1
	}
	r := *(v.(*int))
	return r
}

func (m *MFlag) GetStringFlag(name string) string {
	v, ok := m.flags[name]
	if !ok {
		return ""
	}
	return *(v.(*string))
}

func (m *MFlag) GetBoolFlag(name string) bool {
	v, ok := m.flags[name]
	if !ok {
		return false
	}
	return *(v.(*bool))
}

func (m *MFlag) MarshalJSON() ([]byte, error) {
	result := make(map[string]interface{})
	for k, v := range m.flags {
		// 判断值类型
		name := k
		switch v.(type) {
		case *int:
			result[k] = m.GetIntFlag(name)
		case *string:
			result[k] = m.GetStringFlag(name)
		case *bool:
			result[k] = m.GetBoolFlag(name)
		default:
			continue
		}
		// result[k] = *(v.(*interface{}))
	}
	result["remainArgs"] = m.RemainArgs
	return json.Marshal(result)
}

func (m *MFlag) UnmarshalJSON(data []byte) error {
	var result map[string]interface{}
	err := json.Unmarshal(data, &result)
	if err != nil {
		return err
	}
	for k, v := range result {
		if k == "remainArgs" {
			m.RemainArgs = convert2StringSlice(v.([]interface{}))
			continue
		}
		switch v.(type) {
		case float64:
			p := int(v.(float64))
			m.flags[k] = &p
		case string:
			p := v.(string)
			m.flags[k] = &p
		case bool:
			p := v.(bool)
			m.flags[k] = &p
		default:
			continue
		}
	}
	return nil
}

func convertSlice[T any, U any](input []T, convert func(T) U) []U {
	result := make([]U, len(input))
	for i, v := range input {
		result[i] = convert(v)
	}
	return result
}

func convert2StringSlice[T any](input []T) []string {
	return convertSlice(input, func(v T) string {
		return fmt.Sprint(v)
	})
}