package db

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/sys/log"
	"go_dreamfactory/lego/utils/codec/json"
	"io/ioutil"
	"os"
	"sync"
)

func newSys(options *Options) (sys *DB, err error) {
	sys = &DB{
		options: options,
		data:    make(map[string]*ModelDataExpired),
	}
	if err = sys.init(); err != nil {
		go sys.run()
	}
	return
}

type DB struct {
	options *Options
	local   *DBConn
	cross   *DBConn
	servers map[string]*DBConn
	mu      sync.RWMutex
	data    map[string]*ModelDataExpired //过期数据
}

func (this *DB) init() (err error) {
	if this.local, err = newDBConn(DBConfig{
		RedisIsCluster:  this.options.RedisIsCluster,
		RedisAddr:       this.options.RedisAddr,
		RedisPassword:   this.options.RedisPassword,
		RedisDB:         this.options.RedisDB,
		MongodbUrl:      this.options.MongodbUrl,
		MongodbDatabase: this.options.MongodbDatabase,
	}); err != nil {
		return
	}
	err = this.readercrossconf(this.options.CrossConfig)
	return
}

//读取游戏配置文件
func (this *DB) readercrossconf(path string) (err error) {
	config := make(comm.CrossConfigs, 0)
	var (
		jsonFile  *os.File
		byteValue []byte
	)
	if jsonFile, err = os.Open(path); err != nil {
		return
	} else {
		defer jsonFile.Close()
		if byteValue, err = ioutil.ReadAll(jsonFile); err != nil {
			return
		}
		if err = json.Unmarshal(byteValue, &config); err != nil {
			return
		}
		if cf, ok := config[this.options.CrossTag]; !ok {
			err = fmt.Errorf("no found Crossconfig:%s", this.options.CrossTag)
			return
		} else {
			if !this.options.IsCross {
				if this.cross, err = newDBConn(DBConfig{
					RedisIsCluster:  cf.LoaclDB.RedisIsCluster,
					RedisAddr:       cf.LoaclDB.RedisAddr,
					RedisPassword:   cf.LoaclDB.RedisPassword,
					RedisDB:         cf.LoaclDB.RedisDB,
					MongodbUrl:      cf.LoaclDB.MongodbUrl,
					MongodbDatabase: cf.LoaclDB.MongodbDatabase,
				}); err != nil {
					log.Error("comment db err!", log.Field{Key: "stag", Value: cf.AreaId}, log.Field{Key: "db", Value: cf.LoaclDB}, log.Field{Key: "err", Value: err})
					return
				}
			} else {
				for k, v := range cf.ServiceList {
					if this.servers[k], err = newDBConn(DBConfig{
						RedisIsCluster:  v.RedisIsCluster,
						RedisAddr:       v.RedisAddr,
						RedisPassword:   v.RedisPassword,
						RedisDB:         v.RedisDB,
						MongodbUrl:      v.MongodbUrl,
						MongodbDatabase: v.MongodbDatabase,
					}); err != nil {
						log.Error("comment db err!", log.Field{Key: "stag", Value: k}, log.Field{Key: "db", Value: v}, log.Field{Key: "err", Value: err})
						return
					}
				}
			}
		}
	}
	return
}
func (this *DB) Local() *DBConn {
	if this.local == nil {
		log.Panic("LocalDBConn on init")
	}
	return this.local
}

func (this *DB) Cross() *DBConn {
	if this.cross == nil {
		log.Panic("CrossDBConn on init")
	}
	return this.cross
}

func (this *DB) ServerDBConn(stage string) (conn *DBConn) {
	ok := false
	conn, ok = this.servers[stage]
	if !ok {
		log.Panicf("DBConn:%s on init", stage)
	}
	return
}
func (this *DB) GetServerTags() []string {
	keys := make([]string, 0)
	for k, _ := range this.servers {
		keys = append(keys, k)
	}
	return keys
}