package mdb

import (
	"errors"
	"gitee.com/phpvipzm/zmf"
	"gitee.com/phpvipzm/zmf/lib/zconfig"
	_ "github.com/go-sql-driver/mysql"
	"github.com/jmoiron/sqlx"
	"github.com/spf13/cast"
	"strconv"
	"strings"
	"sync"
	"time"
)

var mDBLock = new(sync.RWMutex)
var mDBCfg map[string]*DbConf = map[string]*DbConf{}

func NewDb(tb string, name string) (ret *MDB) {
	mDBLock.Lock()
	defer mDBLock.Unlock()

	cfg, ok := mDBCfg[name]
	if ok == false {
		cfg = &DbConf{}
		if zconfig.GetCfgSt(name, cfg) {
			mDBCfg[name] = cfg
		}
	}

	shost := cfg.User + ":" + cfg.Password + "@tcp(" + cfg.Host + ")/" + cfg.DataBase + "?charset=utf8mb4&parseTime=false&loc=Local"
	fd, err := sqlx.Open("mysql", shost)
	if err != nil {
		return nil
	}

	fd.SetMaxOpenConns(cfg.MaxOpenConn)
	fd.SetMaxIdleConns(cfg.MaxIdlConn)
	fd.SetConnMaxLifetime(time.Second * time.Duration(cfg.MaxTime))

	ret = &MDB{}
	ret.Param = DbParam{}
	ret.Conf = cfg
	ret.Fd = fd

	ret.Param.Table = ret.Conf.DbName + tb
	ret.Param.LimitStr = ""
	ret.Param.param = H{}
	ret.Param.WhereStr = ""
	ret.Param.OrderStr = ""
	ret.Param.ExpStr = "*"
	return ret
}

func (this *MDB) Limit(page int, count int) (ret *MDB) {
	this.Param.LimitStr = "Limit " + strconv.Itoa(page*count) + "," + strconv.Itoa(count)

	return this
}

func (this *MDB) Where(par H) (ret *MDB) {

	p := []string{}
	for index, value := range par {
		p = append(p, index+"=:"+index)
		this.Param.param[index] = value
	}
	if len(p) < 1 {
		return this
	}
	this.Param.WhereStr = " where " + strings.Join(p, " and ")
	return this
}

func (this *MDB) WhereEx(par map[string]zmf.WHVAL) (ret *MDB) {

	p := []string{}
	for index, value := range par {
		switch value.Op {
		case "=":
			p = append(p, index+"=:"+index)
			this.Param.param[index] = value.Value
			break
		case "!=":
			p = append(p, index+"!=:"+index)
			this.Param.param[index] = value.Value
			break
		case ">":
			p = append(p, index+">:"+index)
			this.Param.param[index] = value.Value
			break
		case "<":
			p = append(p, index+"<:"+index)
			this.Param.param[index] = value.Value
			break
		case "include":
			p = append(p, index+" like:"+index)
			this.Param.param[index] = "%" + cast.ToString(value.Value) + "%"
			break
		case "notinclude":
			p = append(p, index+" not like:"+index)
			this.Param.param[index] = "%" + cast.ToString(value.Value) + "%"
			break
		case "<>":
			str := cast.ToString(value.Value)
			bt := strings.Split(str, ",")
			if len(bt) != 2 {
				break
			}
			p = append(p, index+" between:"+index+"0 and :"+index+"1")
			this.Param.param[index+"0"] = bt[0]
			this.Param.param[index+"1"] = bt[1]
			break

		default:
			break
		}

	}
	if len(p) < 1 {
		return this
	}
	this.Param.WhereStr = " where " + strings.Join(p, " and ")

	return this
}

func (this *MDB) WhereOr(par H) (ret *MDB) {
	p := []string{}
	for index, value := range par {
		p = append(p, index+"=:"+index)
		this.Param.param[index] = value
	}
	if len(p) < 1 {
		return this
	}

	this.Param.WhereStr = " where " + strings.Join(p, " or ")
	return this
}
func (this *MDB) Order(par H) (ret *MDB) {

	p := []string{}
	for index, value := range par {
		v, e := value.(string)
		if e {
			switch v {
			case "desc":
				p = append(p, index+" DESC")
				break
			case "asc":
				p = append(p, index+" ASC")
				break
			default:
				break
			}
		}

	}
	if len(p) < 1 {
		return this
	}
	this.Param.OrderStr = " ORDER BY " + strings.Join(p, ",")
	return this
}
func (this *MDB) Exp(par string) (ret *MDB) {
	this.Param.ExpStr = par
	return this
}

func (this *MDB) Add(par map[string]interface{}) (rt int64, _err error) {
	defer this.Fd.Close()
	p := []string{}
	for index, value := range par {
		p = append(p, index+"=:"+index)
		this.Param.param[index] = value
	}
	sqlStr := "insert into " + "`" + this.Param.Table + "` SET " + strings.Join(p, ",")

	result, err := this.Fd.NamedExec(sqlStr, this.Param.param)
	if err != nil {
		return 0, err
	}
	id, _ := result.LastInsertId()
	return id, nil
}

func (this *MDB) Update(par map[string]interface{}) (e error) {
	defer this.Fd.Close()
	p := []string{}
	for index, value := range par {
		key := "V_" + index + "_V"
		p = append(p, index+"=:"+key)
		this.Param.param[key] = value
	}
	sqlStr := "update " + "`" + this.Param.Table + "` SET " + strings.Join(p, ",") + this.Param.WhereStr

	_, err := this.Fd.NamedExec(sqlStr, this.Param.param)
	if err != nil {
		return err
	}
	return nil
}

func (this *MDB) Del() (e error) {
	defer this.Fd.Close()
	sqlStr := "delete " + " FROM `" + this.Param.Table + "` " + this.Param.WhereStr
	_, err := this.Fd.NamedQuery(sqlStr, this.Param.param)
	if err != nil {
		return err
	}
	return nil
}

func getMapData(row *sqlx.Rows) (ret []map[string]interface{}) {
	dat := []map[string]interface{}{}

	for row.Next() {
		re := map[string]interface{}{}
		err := row.MapScan(re)
		if err != nil {
			return dat
		}

		for k, v := range re {
			if vl, ok := v.([]byte); ok {
				re[k] = string(vl)
			}
		}
		dat = append(dat, re)
	}

	return dat
}

func (this *MDB) One() (data map[string]interface{}, rt error) {
	defer this.Fd.Close()
	sqlStr := "select " + this.Param.ExpStr + " FROM `" + this.Param.Table + "` " + this.Param.WhereStr + this.Param.OrderStr + " Limit 0,1"
	row, err := this.Fd.NamedQuery(sqlStr, this.Param.param)

	if err != nil {
		return nil, err
	}
	defer row.Close()

	dat := getMapData(row)

	if len(dat) < 1 {
		return nil, errors.New("not find")
	}
	return dat[0], nil
}
func (this *MDB) All() (data []map[string]interface{}, rt error) {
	defer this.Fd.Close()
	sqlStr := "select " + this.Param.ExpStr + " FROM `" + this.Param.Table + "` " + this.Param.WhereStr + " " + this.Param.OrderStr + " " + this.Param.LimitStr

	row, err := this.Fd.NamedQuery(sqlStr, this.Param.param)

	if err != nil {
		return nil, err
	}
	defer row.Close()

	return getMapData(row), nil
}
func (this *MDB) Count() (c int) {
	defer this.Fd.Close()
	sqlStr := "select count(*)" + " FROM `" + this.Param.Table + "` " + this.Param.WhereStr + " " + this.Param.OrderStr + " " + this.Param.LimitStr
	row, err := this.Fd.NamedQuery(sqlStr, this.Param.param)

	if err != nil {
		return 0
	}
	defer row.Close()

	tl := 0
	if row.Next() {
		err := row.Scan(&tl)
		if err != nil {
			return 0
		}
		return tl
	}

	return 0
}
func (this *MDB) Map(data []map[string]interface{}, key string, fun func(data map[string]interface{}) (r map[string]interface{})) {
	defer this.Fd.Close()
	arrKey := []string{}
	arr := map[string]interface{}{}
	vmKey := map[string]string{}
	for index, value := range data {
		vv := cast.ToString(value[key])
		if vv == "" {
			continue
		}
		_, ok := vmKey[vv]
		if ok {
			continue
		}

		akey := key + "_" + strconv.Itoa(index)
		arrKey = append(arrKey, ":"+akey)
		arr[akey] = vv

	}
	sqlStr := "select " + this.Param.ExpStr + " FROM `" + this.Param.Table + "` WHERE " + key + " IN (" + strings.Join(arrKey, ",") + ")"

	rows, err := this.Fd.NamedQuery(sqlStr, arr)
	if err != nil {
		return
	}
	defer rows.Close()

	ret := getMapData(rows)

	rmap := map[string](map[string]interface{}){}
	for _, value := range ret {
		rval := fun(value)
		if rval == nil {
			break
		}
		vl := cast.ToString(value[key])
		if vl == "" {
			continue
		}
		rmap[vl] = rval

	}
	for index, value := range data {
		vv := cast.ToString(value[key])
		if vv == "" {
			continue
		}
		_, ok := vmKey[vv]
		if ok {
			continue
		}

		if _, e := rmap[vv]; e {
			zmf.MapMerge(&data[index], rmap[vv])
		}

	}
	return
}

func (this *MDB) Begin() (tx *sqlx.Tx) {
	return this.Fd.MustBegin()
}