package model

import (
	"errors"
	"fmt"
	"regexp"
	"time"
)

// Commands - struct
type Commands struct {
	Cmd     string    `db:"cmd" cc:"cmd"`
	Message string    `db:"message" cc:"message"`
	Group   string    `db:"group" cc:"group"`
	Ctime   time.Time `db:"ctime" cc:"ctime"`
	Mtime   time.Time `db:"mtime" cc:"ctime"`
}

// CommandsWithGroup -
type CommandsWithGroup struct {
	Commands  `cc:"-,<<"`
	GroupName string `db:"group_name" cc:"group_name"`
}

// GetAllCommands -
func GetAllCommands() (cmds []*Commands, err error) {
	err = x.Select(&cmds, `select * from "public"."commands"`)
	return
}

// GetGroupCommand -
func GetGroupCommand(c, g string) (cmd *Commands, err error) {
	if len(c) == 0 {
		return nil, errors.New("command is empty")
	}
	query := `select c.* from "public"."commands" c
		where c."cmd" = $1
		and (c."group" = '' or c."group" = $2)
		order by c."group" desc
		limit 1`
	row := x.QueryRowx(query, c, g)
	// err = x.Get(&cmd, query, c, g)
	cmd = &Commands{}
	err = row.StructScan(cmd)
	if err != nil {
		return nil, err
	}
	return
}

// GetCommandCount -
func GetCommandCount(where ...interface{}) (c int, err error) {
	query := `select count(*) as c from "public"."commands"`
	values := make([]interface{}, 0)
	if len(where) > 0 {
		if whereMap, ok := where[0].(map[string]string); ok {
			str := ""
			idx := 1
			for k, v := range whereMap {
				if len(str) > 0 {
					str += " and "
				}
				str += fmt.Sprintf(` "%s" = $%d `, k, idx)
				idx++
				values = append(values, v)
			}
			if len(str) > 0 {
				query += ` where ` + str
			}
		}
	}
	err = x.Get(&c, query, values...)
	return
}

// GetCommands -
func GetCommands(where map[string]string, offset, limit int, order map[string]string) (cmds []*CommandsWithGroup, err error) {
	query := `select c.*, (case when g.name is null then '' else g.name end) as group_name from "public"."commands" c
		left join "public"."line_group" g
		on g.id = c.group `
	values := make([]interface{}, (len(where) + len(order)))
	idx := 1

	if len(where) > 0 {
		str := ""
		for k, v := range where {
			if len(str) > 0 {
				str += " and "
			}
			str += fmt.Sprintf(` "%s" = $%d `, k, idx)
			idx++
			values = append(values, v)
		}
		if len(str) > 0 {
			query += ` where ` + str
		}
	}
	if offset >= 0 {
		query += fmt.Sprintf(" offset %d ", offset)
	}
	if limit > 0 {
		query += fmt.Sprintf(" limit %d ", limit)
	}

	if len(order) > 0 {
		regex, err := regexp.Compile("(?i)(desc|asc)")
		if err != nil {
			return nil, err
		}
		str := ""
		for k, v := range order {
			if !regex.Match([]byte(v)) {
				continue
			}
			if len(str) > 0 {
				str += " , "
			}
			str += fmt.Sprintf(` "%s" %s `, k, v)
		}
	}

	err = x.Select(&cmds, query, values...)

	return
}

// AddCommand -
func AddCommand(cmdkey, message, group string) (cmd *Commands, err error) {
	if len(cmdkey) == 0 || len(message) == 0 {
		return nil, errors.New("cmd or message is empty")
	}
	query := `insert into "public"."commands" ("cmd", "message", "group") values ($1, $2, $3) returning *`
	cmd = &Commands{}
	err = x.Get(cmd, query, cmdkey, message, group)
	if err != nil {
		return nil, err
	}
	return
}

// CheckCommand -
func CheckCommand(cmd, group string) (exist bool, err error) {
	if len(cmd) == 0 {
		return false, errors.New("cmd is empty")
	}
	query := `select count(*) as c from "public"."commands" where "cmd" = $1 and "group" = $2`
	c := 0

	err = x.Get(&c, query, cmd, group)
	if err != nil {
		return false, err
	}

	return c > 0, nil
}

// DeleteCommand -
func DeleteCommand(cmd, group string) (err error) {
	if len(cmd) == 0 {
		return errors.New("cmd is empty")
	}
	query := `delete from "public"."commands" where "cmd" = $1 and "group" = $2`
	_, err = x.Exec(query, cmd, group)
	return
}

// UpdateCommand -
func UpdateCommand(cmd, group, message string) (err error) {
	if len(cmd) == 0 || len(message) == 0 {
		return errors.New("cmd or message is empty")
	}

	query := `update "public"."commands" set "message" = $1, "mtime" = now() where "cmd" = $2 and "group" = $3`
	_, err = x.Exec(query, message, cmd, group)
	return
}