package v1

import (
	"context"
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"

	"go-common/app/infra/config/model"
	"go-common/library/database/sql"
	"go-common/library/ecode"
	"go-common/library/log"
	xtime "go-common/library/time"
)

const (
	_buildVerKey = "%s_%s_%s"
	_pushKey     = "%s_%s_%s"
	_cacheKey    = "%s_%s_%d_%s"
	_cacheKey2   = "%s_%s_%d_%s_2"
	_fileKey     = "%s_%d"
)

var (
	addBusiness    = "前端接口api添加配置版本"
	addInfo        = "添加版本:%d"
	copyBusiness   = "前端接口api拷贝配置版本"
	copyInfo       = "拷贝版本:%d，新的版本:%d"
	updateBusiness = "前端接口api更新配置"
	updateInfo     = "更新版本:%d"
)

// PushKey push sub id
func pushKey(svr, host, env string) string {
	return fmt.Sprintf(_pushKey, svr, host, env)
}

// buildVerKey version mapping key
func buildVerKey(svr, bver, env string) string {
	return fmt.Sprintf(_buildVerKey, svr, bver, env)
}

// cacheKey config cache key
func cacheKey(svr, bver, env string, ver int64) string {
	return fmt.Sprintf(_cacheKey, svr, bver, ver, env)
}

// cacheKey config cache key
func cacheKey2(svr, bver, env string, ver int64) string {
	return fmt.Sprintf(_cacheKey2, svr, bver, ver, env)
}

// fileKey
func fileKey(filename string, ver int64) string {
	return fmt.Sprintf(_fileKey, filename, ver)
}

// tokenKey
func tokenKey(svr, env string) string {
	return fmt.Sprintf("%s_%s", svr, env)
}

// genConfig generate config
func genConfig(ver int64, cs []*model.NSValue) (conf *model.Content, err error) {
	var b []byte
	data := make(map[string]string)
	for _, c := range cs {
		data[c.Name] = c.Config
	}
	if b, err = json.Marshal(data); err != nil {
		return
	}
	mb := md5.Sum(b)
	conf = &model.Content{
		Version: ver,
		Md5:     hex.EncodeToString(mb[:]),
		Content: string(b),
	}
	return
}

// genConfig2 generate config
func genConfig2(ver int64, cs []*model.NSValue, ns map[int64]string) (conf *model.Content, err error) {
	var (
		b  []byte
		v  string
		ok bool
		s  *model.Namespace
	)
	nsc := make(map[string]*model.Namespace)
	for _, c := range cs {
		if v, ok = ns[c.NamespaceID]; !ok && c.NamespaceID != 0 {
			continue
		}
		if s, ok = nsc[v]; !ok {
			s = &model.Namespace{Name: v, Data: map[string]string{}}
			nsc[v] = s
		}
		s.Data[c.Name] = c.Config
	}
	if b, err = json.Marshal(nsc); err != nil {
		return
	}
	mb := md5.Sum(b)
	conf = &model.Content{
		Version: ver,
		Md5:     hex.EncodeToString(mb[:]),
		Content: string(b),
	}
	return
}

// Push version to clients & generate config caches
func (s *Service) Push(c context.Context, svr *model.Service) (err error) {
	var (
		hosts      []*model.Host
		values     []*model.NSValue
		conf       *model.Content
		conf2      *model.Content
		namespaces map[int64]string
	)
	if values, err = s.dao.Values(c, svr.Version); err != nil {
		return
	}
	if namespaces, err = s.dao.Namespaces(c, svr.Version); err != nil {
		return
	}
	if len(values) == 0 {
		err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
		log.Error("%v", err)
		return
	}
	// compatible old version sdk
	if conf, err = genConfig(svr.Version, values); err != nil {
		log.Error("get config value:%s error(%v) ", values, err)
		return
	}
	cacheKey := cacheKey(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
	if err = s.dao.SetFile(cacheKey, conf); err != nil {
		log.Error("set confCashe error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Env)
		err = nil
	}
	if conf2, err = genConfig2(svr.Version, values, namespaces); err != nil {
		log.Error("get config2 value:%s error(%v) ", values, err)
		return
	}
	cacheKey2 := cacheKey2(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
	if err = s.dao.SetFile(cacheKey2, conf2); err != nil {
		log.Error("set confCashe2 error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Env)
		err = nil
	}
	s.setVersion(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
	// push hosts
	if hosts, err = s.dao.Hosts(c, svr.Name, svr.Env); err != nil {
		log.Error("get hosts error. svr:%s, buildVer:%s, ver:%d", svr.Name, svr.BuildVersion, svr.Version)
		err = nil
		return
	}
	for _, h := range hosts {
		if h.State == model.HostOnline {
			pushKey := pushKey(h.Service, h.Name, svr.Env)
			if ok := s.pubEvent(pushKey, &model.Version{Version: conf.Version}); ok {
				log.Info("s.events.Pub(%s, %d) ok: %t", pushKey, conf.Version, ok)
			}
		}
	}
	return
}

// Config return config content.
func (s *Service) Config(c context.Context, svr *model.Service) (conf *model.Content, err error) {
	var values []*model.NSValue
	if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
		return
	}
	cacheName := cacheKey(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
	if conf, err = s.dao.File(cacheName); err == nil {
		return
	}
	if values, err = s.dao.Values(c, svr.Version); err != nil {
		return
	}
	if len(values) == 0 {
		err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
		log.Error("%v", err)
		return
	}
	if conf, err = genConfig(svr.Version, values); err != nil {
		log.Error("get config value:%s error(%v) ", values, err)
		return
	}
	if err = s.dao.SetFile(cacheName, conf); err != nil {
		err = nil
	}
	return
}

// Config2 return config content.
func (s *Service) Config2(c context.Context, svr *model.Service) (conf *model.Content, err error) {
	var (
		values     []*model.NSValue
		namespaces map[int64]string
	)
	if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
		return
	}
	cacheName := cacheKey2(svr.Name, svr.BuildVersion, svr.Env, svr.Version)
	if conf, err = s.dao.File(cacheName); err == nil {
		return
	}
	if namespaces, err = s.dao.Namespaces(c, svr.Version); err != nil {
		return
	}
	if values, err = s.dao.Values(c, svr.Version); err != nil {
		return
	}
	if len(values) == 0 {
		err = fmt.Errorf("config values is empty. svr:%s, host:%s, buildVer:%s, ver:%d", svr.Name, svr.Host, svr.BuildVersion, svr.Version)
		log.Error("%v", err)
		return
	}
	if conf, err = genConfig2(svr.Version, values, namespaces); err != nil {
		log.Error("get config value:(%s) error(%v) ", values, err)
		return
	}
	if err = s.dao.SetFile(cacheName, conf); err != nil {
		err = nil
	}
	return
}

// File get one file content.
func (s *Service) File(c context.Context, svr *model.Service) (val string, err error) {
	var (
		curVer int64
		ok     bool
	)
	if err = s.appAuth(c, svr.Name, svr.Env, svr.Token); err != nil {
		return
	}
	if svr.Version != model.UnknownVersion {
		curVer = svr.Version
	} else {
		curVer, ok = s.version(svr.Name, svr.BuildVersion, svr.Env)
		if !ok {
			if curVer, err = s.dao.BuildVersion(c, svr.Name, svr.BuildVersion, svr.Env); err != nil {
				log.Error("BuildVersion(%v) error(%v)", svr, err)
				return
			}
			s.setVersion(svr.Name, svr.BuildVersion, svr.Env, curVer)
		}
	}
	fKey := fileKey(svr.File, curVer)
	if val, err = s.dao.FileStr(fKey); err == nil {
		return
	}
	if val, err = s.dao.Value(c, svr.File, curVer); err != nil {
		log.Error("Value(%v) error(%v)", svr.File, err)
		return
	}
	s.dao.SetFileStr(fKey, val)
	return
}

// CheckVersion check client version.
func (s *Service) CheckVersion(c context.Context, rhost *model.Host, env, token string) (evt chan *model.Version, err error) {
	var (
		curVer int64
	)
	if err = s.appAuth(c, rhost.Service, env, token); err != nil {
		return
	}
	// set heartbeat
	rhost.HeartbeatTime = xtime.Time(time.Now().Unix())
	if err = s.dao.SetHost(c, rhost, rhost.Service, env); err != nil {
		err = nil
	}
	evt = make(chan *model.Version, 1)
	if rhost.Appoint > 0 {
		if rhost.Appoint != rhost.ConfigVersion {
			evt <- &model.Version{Version: rhost.Appoint}
		}
		return
	}
	// get current version, return if has new config version
	if curVer, err = s.curVer(c, rhost.Service, rhost.BuildVersion, env); err != nil {
		return
	}

	if curVer == model.UnknownVersion {
		err = ecode.NothingFound
		return
	}
	if curVer != rhost.ConfigVersion {
		evt <- &model.Version{Version: curVer}
		return
	}
	pushKey := pushKey(rhost.Service, rhost.Name, env)
	s.eLock.Lock()
	s.events[pushKey] = evt
	s.eLock.Unlock()
	return
}

// AppAuth check app is auth
func (s *Service) appAuth(c context.Context, svr, env, token string) (err error) {
	var (
		dbToken  string
		ok       bool
		tokenKey = tokenKey(svr, env)
	)
	s.eLock.RLock()
	dbToken, ok = s.token[tokenKey]
	s.eLock.RUnlock()
	if !ok {
		if dbToken, err = s.dao.Token(c, svr, env); err != nil {
			log.Error("Token(%v,%v) error(%v)", svr, env, err)
			return
		}
		s.SetToken(c, svr, env, dbToken)
	}

	if dbToken != token {
		err = ecode.AccessDenied
	}
	return
}

// SetToken update Token
func (s *Service) SetToken(c context.Context, svr, env, token string) {
	tokenKey := tokenKey(svr, env)
	s.eLock.Lock()
	s.token[tokenKey] = token
	s.eLock.Unlock()
}

// Hosts return client hosts.
func (s *Service) Hosts(c context.Context, svr, env string) (hosts []*model.Host, err error) {
	return s.dao.Hosts(c, svr, env)
}

// VersionSuccess return client versions which configuration is complete
func (s *Service) VersionSuccess(c context.Context, svr, env, bver string) (versions *model.Versions, err error) {
	var (
		vers []*model.ReVer
		ver  int64
	)
	if vers, err = s.dao.Versions(c, svr, env, model.ConfigEnd); err != nil {
		log.Error("Versions(%v,%v,%v) error(%v)", svr, env, bver, err)
		return
	}
	if ver, err = s.dao.BuildVersion(c, svr, bver, env); err != nil {
		log.Error("BuildVersion(%v) error(%v)", svr, err)
		return
	}
	versions = &model.Versions{
		Version: vers,
		DefVer:  ver,
	}
	return
}

// VersionIng return client versions which configuration is creating
func (s *Service) VersionIng(c context.Context, svr, env string) (vers []int64, err error) {
	var (
		res []*model.ReVer
	)
	if res, err = s.dao.Versions(c, svr, env, model.ConfigIng); err != nil {
		log.Error("Versions(%v,%v) error(%v)", svr, env, err)
		return
	}
	vers = make([]int64, 0)
	for _, reVer := range res {
		vers = append(vers, reVer.Version)
	}
	return
}

// Builds all builds
func (s *Service) Builds(c context.Context, svr, env string) (builds []string, err error) {
	return s.dao.Builds(c, svr, env)
}

// AddConfigs insert config into db.
func (s *Service) AddConfigs(c context.Context, svr, env, token, user string, data map[string]string) (err error) {
	var (
		svrID int64
		ver   int64
	)
	if err = s.appAuth(c, svr, env, token); err != nil {
		return
	}
	if svrID, err = s.dao.ServiceID(c, svr, env); err != nil {
		return
	}
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("begin tran error(%v)", err)
		return
	}
	if ver, err = s.dao.TxInsertVer(tx, svrID, user); err != nil {
		tx.Rollback()
		return
	}
	if len(data) != 0 {
		if err = s.dao.TxInsertValues(c, tx, ver, user, data); err != nil {
			tx.Rollback()
			return
		}
	}
	if err = tx.Commit(); err != nil {
		log.Error("tx.Commit error(%v)", err)
		return
	}
	s.dao.InsertLog(c, user, addBusiness, fmt.Sprintf(addInfo, ver))
	return
}

// CopyConfigs copy config in newVer.
func (s *Service) CopyConfigs(c context.Context, svr, env, token, user string, build string) (ver int64, err error) {
	var (
		svrID  int64
		curVer int64
		values []*model.NSValue
	)
	if err = s.appAuth(c, svr, env, token); err != nil {
		return
	}
	if curVer, err = s.curVer(c, svr, build, env); err != nil {
		return
	}
	if values, err = s.dao.Values(c, curVer); err != nil {
		return
	}
	data := make(map[string]string)
	for _, c := range values {
		data[c.Name] = c.Config
	}
	if svrID, err = s.dao.ServiceID(c, svr, env); err != nil {
		return
	}
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("begin tran error(%v)", err)
		return
	}
	if ver, err = s.dao.TxInsertVer(tx, svrID, user); err != nil {
		tx.Rollback()
		return
	}
	if err = s.dao.TxInsertValues(c, tx, ver, user, data); err != nil {
		tx.Rollback()
		return
	}
	if err = tx.Commit(); err != nil {
		log.Error("tx.Commit error(%v)", err)
		return
	}
	s.dao.InsertLog(c, user, copyBusiness, fmt.Sprintf(copyInfo, curVer, ver))
	return
}

// UpdateConfigs update config.
func (s *Service) UpdateConfigs(c context.Context, svr, env, token, user string, ver int64, data map[string]string) (err error) {
	var (
		values  []*model.NSValue
		addData = make(map[string]string)
		udata   = make(map[string]string)
	)
	if err = s.appAuth(c, svr, env, token); err != nil {
		return
	}
	if len(data) == 0 {
		return
	}
	if values, err = s.dao.Values(c, ver); err != nil {
		return
	}
	if len(values) == 0 {
		return ecode.NothingFound
	}
	oldData := make(map[string]string)
	for _, c := range values {
		oldData[c.Name] = c.Config
	}
	for k, v := range data {
		if _, ok := oldData[k]; ok {
			udata[k] = v
		} else {
			addData[k] = v
		}
	}
	var tx *sql.Tx
	if tx, err = s.dao.BeginTran(c); err != nil {
		log.Error("begin tran error(%v)", err)
		return
	}
	if len(addData) != 0 {
		if err = s.dao.TxInsertValues(c, tx, ver, user, addData); err != nil {
			tx.Rollback()
			return
		}
	}
	if len(udata) != 0 {
		if err = s.dao.TxUpdateValues(tx, ver, user, udata); err != nil {
			tx.Rollback()
			return
		}
	}
	if err = tx.Commit(); err != nil {
		log.Error("tx.Commit error(%v)", err)
		return
	}
	s.dao.InsertLog(c, user, updateBusiness, fmt.Sprintf(updateInfo, ver))
	return
}

func (s *Service) version(svr, bver, env string) (ver int64, ok bool) {
	verKey := buildVerKey(svr, bver, env)
	s.vLock.RLock()
	ver, ok = s.versions[verKey]
	s.vLock.RUnlock()
	return
}

func (s *Service) setVersion(svr, bver, env string, ver int64) {
	verKey := buildVerKey(svr, bver, env)
	s.vLock.Lock()
	s.versions[verKey] = ver
	s.vLock.Unlock()
}

// ClearHost clear service hosts.
func (s *Service) ClearHost(c context.Context, svr, env string) (err error) {
	return s.dao.ClearHost(c, svr, env)
}

// pubEvent publish a event to chan.
func (s *Service) pubEvent(key string, evt *model.Version) (ok bool) {
	s.eLock.RLock()
	c, ok := s.events[key]
	s.eLock.RUnlock()
	if ok {
		c <- evt
	}
	return
}

// Unsub unsub a event.
func (s *Service) Unsub(svr, host, env string) {
	key := pushKey(svr, host, env)
	s.eLock.Lock()
	delete(s.events, key)
	s.eLock.Unlock()
}

func (s *Service) curVer(c context.Context, svr, build, env string) (ver int64, err error) {
	var ok bool
	// get current version, return if has new config version
	ver, ok = s.version(svr, build, env)
	if !ok {
		if ver, err = s.dao.BuildVersion(c, svr, build, env); err != nil {
			return
		}
		s.setVersion(svr, build, env, ver)
	}
	return
}