package models
  
  import (

  	"fmt"

  	"github.com/garyburd/redigo/redis"
  	"pro2d/common"
  	"pro2d/common/db/mongoproxy"
  	"pro2d/common/db/redisproxy"
  	"pro2d/common/logger"
  	"pro2d/pb"
  	"reflect"
  )
  
  type STOIncrement map[interface{}]int64
  
  var dbSeedSingleton *DBSeed
  
  type DBSeed struct {
  	serverID int64
  }
  
  func NewDBSeed(serverID int64) *DBSeed {
  	if dbSeedSingleton == nil {
  		dbSeedSingleton = &DBSeed{
  			serverID: serverID,
  		}
  	}
  	return dbSeedSingleton
  }
  
  func DBSeedS() *DBSeed {
  	return dbSeedSingleton
  }
  
  func AccountModels() STOIncrement {
  	return STOIncrement{
  		&pb.Account{}: 0,
  		"uid":         common.MaxUidNum,
  	}
  }
  
  func GameModels() STOIncrement {
  	return STOIncrement{
  		&pb.Increment{}: 0,
  		&pb.Role{}:      common.MaxCommNum,
  		&pb.Equipment{}: 0,
  		&pb.Hero{}:      0,
  		&pb.Prop{}:      0,
  		&pb.Team{}:      0,
  	}
  }
  
  //初始化表自增id
  func (d *DBSeed) InitAutoIncreUidTable(schema STOIncrement) {
  	for s, b := range schema {
  		if b <= 0 {
  			continue
  		}
  		var name string
  		if reflect.TypeOf(s).Kind() == reflect.String {
  			name = s.(string)
  		} else {
  			name = mongoproxy.GetCollName(s)
  		}
  
  		autoIncrement := NewIncrement(name)
  		var increId int64 = 0
  		if err := autoIncrement.Load(); err != nil {
  			//字段不存在 初始化 id
  			increId = d.serverID * b
  			autoIncrement.Incre.Key = name
  			autoIncrement.Incre.Val = increId
  			autoIncrement.Create()
  
  		} else {
  			increId = autoIncrement.Incre.Val
  		}
  
  		//设置到redis中，提供初始自增id

  		relay, err := redisproxy.HGET(fmt.Sprintf(common.AutoIncrement, d.serverID), name)

  		if err != nil {
  			logger.Error(err.Error())
  			continue
  		}
  
  		var relayID int64 = 0
  		if relay != nil {
  			relayID, err = redis.Int64(relay, err)
  			if err != nil {
  				logger.Error(err.Error())
  				continue
  			}
  		}
  

  		logger.Debug(relayID, fmt.Sprintf(common.AutoIncrement, d.serverID), name)

  		if relayID == 0 || increId > relayID {

  			redisproxy.HSET(fmt.Sprintf(common.AutoIncrement, d.serverID), name, increId)

  		}
  	}
  }
  
  func (d *DBSeed) SaveAutoincrementTimer(schema STOIncrement) {
  	for s, b := range schema {
  		if b <= 0 {
  			continue
  		}
  		var name string
  		if reflect.TypeOf(s).Kind() == reflect.String {
  			name = s.(string)
  		} else {
  			name = mongoproxy.GetCollName(s)
  		}
  
  		//获取数据库中的id 持久化数据
  		autoIncrement := NewIncrement(name)
  		var dbID int64 = 0
  		if err := autoIncrement.Load(); err != nil {
  			continue
  
  		} else {
  			dbID = autoIncrement.Incre.Val
  		}
  		//获取redis中的id 内存中的数据。获取自增id

  		relayID, err := redis.Int64(redisproxy.HGET(fmt.Sprintf(common.AutoIncrement, d.serverID), name))

  		if err != nil {
  			logger.Error(err.Error())
  			continue
  		}
  		if relayID > dbID {
  			//持久化数据
  			autoIncrement.SetProperty("val", relayID)
  			autoIncrement.Update()
  		}
  	}
  }
  
  //初始化服务器数据库以及服务器信息表
  func (d *DBSeed) InitServerDatabase(schema STOIncrement) {
  	for s, _ := range schema {
  		if reflect.TypeOf(s).Kind() == reflect.String {
  			continue
  		}
  
  		coll, keys := mongoproxy.FindIndex(s)
  		mongoproxy.CreateTable(coll)
  		for _, index := range keys {
  			res, err := mongoproxy.SetUnique(coll, index)
  			if err != nil {
  				logger.Error("InitDoc unique: %s, err: %v", res, err)
  				continue
  			}
  		}
  	}
  }