package show

import (
	"strconv"
	"time"

	clive "go-common/app/interface/main/app-card/model/card/live"
	"go-common/app/interface/main/app-card/model/card/operate"
	"go-common/app/interface/main/app-card/model/card/rank"
	"go-common/app/interface/main/app-show/conf"
	accdao "go-common/app/interface/main/app-show/dao/account"
	actdao "go-common/app/interface/main/app-show/dao/activity"
	addao "go-common/app/interface/main/app-show/dao/ad"
	arcdao "go-common/app/interface/main/app-show/dao/archive"
	adtdao "go-common/app/interface/main/app-show/dao/audit"
	bgmdao "go-common/app/interface/main/app-show/dao/bangumi"
	carddao "go-common/app/interface/main/app-show/dao/card"
	dbusdao "go-common/app/interface/main/app-show/dao/databus"
	dyndao "go-common/app/interface/main/app-show/dao/dynamic"
	livedao "go-common/app/interface/main/app-show/dao/live"
	locdao "go-common/app/interface/main/app-show/dao/location"
	rcmmdao "go-common/app/interface/main/app-show/dao/recommend"
	regiondao "go-common/app/interface/main/app-show/dao/region"
	reldao "go-common/app/interface/main/app-show/dao/relation"
	resdao "go-common/app/interface/main/app-show/dao/resource"
	showdao "go-common/app/interface/main/app-show/dao/show"
	tagdao "go-common/app/interface/main/app-show/dao/tag"
	"go-common/app/interface/main/app-show/model/card"
	recmod "go-common/app/interface/main/app-show/model/recommend"
	"go-common/app/interface/main/app-show/model/region"
	"go-common/app/interface/main/app-show/model/show"
	creativeAPI "go-common/app/interface/main/creative/api"
	"go-common/app/service/main/archive/api"
	resource "go-common/app/service/main/resource/model"
	httpx "go-common/library/net/http/blademaster"
	"go-common/library/stat/prom"
)

type recommend struct {
	key  string
	aids []int64
}

type rcmmndCfg struct {
	Aid   int64  `json:"aid"`
	Goto  string `json:"goto"`
	Title string `json:"title"`
	Cover string `json:"cover"`
}

// Service is show service.
type Service struct {
	c              *conf.Config
	creativeClient creativeAPI.CreativeClient
	dao            *showdao.Dao
	rcmmnd         *rcmmdao.Dao
	ad             *addao.Dao // cptbanner
	bgm            *bgmdao.Dao
	lv             *livedao.Dao
	// bnnr   *bnnrdao.Dao
	adt  *adtdao.Dao
	tag  *tagdao.Dao
	arc  *arcdao.Dao
	dbus *dbusdao.Dao
	dyn  *dyndao.Dao
	res  *resdao.Dao
	// artic   *articledao.Dao
	client *httpx.Client
	rg     *regiondao.Dao
	cdao   *carddao.Dao
	act    *actdao.Dao
	acc    *accdao.Dao
	// relation
	reldao *reldao.Dao
	loc    *locdao.Dao

	tick time.Duration

	rcmmndCache         []*show.Item
	rcmmndOseaCache     []*show.Item
	regionCache         map[string][]*show.Item
	regionOseaCache     map[string][]*show.Item
	regionBgCache       map[string][]*show.Item
	regionBgOseaCache   map[string][]*show.Item
	regionBgEpCache     map[string][]*show.Item
	regionBgEpOseaCache map[string][]*show.Item
	bgmCache            map[int8][]*show.Item
	liveCount           int
	liveMoeCache        []*show.Item // TODO change to liveMoeCache
	liveHotCache        []*show.Item // TODO change to liveHotCache
	bannerCache         map[int8]map[int][]*resource.Banner
	cache               map[string][]*show.Show
	cacheBg             map[string][]*show.Show
	cacheBgEp           map[string][]*show.Show
	tempCache           map[string][]*show.Show
	auditCache          map[string]map[int]struct{} // audit mobi_app builds
	blackCache          map[int64]struct{}          // black aids

	logCh     chan infoc
	logFeedCh chan interface{}
	rcmmndCh  chan recommend
	logPath   string

	// loadfile
	jsonOn bool
	// cpm percentage   0~100
	cpmNum       int
	cpmMid       map[int64]struct{}
	cpmAll       bool
	cpmRcmmndNum int
	cpmRcmmndMid map[int64]struct{}
	cpmRcmmndAll bool
	adIsPost     bool
	// recommend api
	rcmmndOn    bool
	rcmmndGroup map[int64]int    // mid -> group
	rcmmndHosts map[int][]string // group -> hosts
	// region
	reRegionCache map[int]*region.Region
	// ranking
	rankCache     []*show.Item
	rankOseaCache []*show.Item
	// card
	cardCache       map[string][]*show.Show
	columnListCache map[int]*card.ColumnList
	cardSetCache    map[int64]*operate.CardSet
	eventTopicCache map[int64]*operate.EventTopic
	// hot card
	hotTenTabCardCache map[int][]*recmod.CardList
	rankAidsCache      []int64
	rankScoreCache     map[int64]int64
	rankArchivesCache  map[int64]*api.Arc
	// hotCache           []*card.PopularCard
	rcmdCache       []*card.PopularCard
	hottopicsCache  []*clive.TopicHot
	rankCache2      []*rank.Rank
	dynamicHotCache []*clive.DynamicHot
	// prom
	pHit  *prom.Prom
	pMiss *prom.Prom
}

// New new a show service.
func New(c *conf.Config) (s *Service) {
	rcmmndHosts := make(map[int][]string, len(c.Recommend.Host))
	for k, v := range c.Recommend.Host {
		key, err := strconv.Atoi(k)
		if err != nil {
			continue
		}
		rcmmndHosts[key] = v
	}
	rcmmndGroup := make(map[int64]int, len(c.Recommend.Group))
	for k, v := range c.Recommend.Group {
		key, err := strconv.Atoi(k)
		if err != nil {
			continue
		}
		rcmmndGroup[int64(key)] = v
	}
	s = &Service{
		c:      c,
		dao:    showdao.New(c),
		rcmmnd: rcmmdao.New(c),
		ad:     addao.New(c),
		bgm:    bgmdao.New(c),
		lv:     livedao.New(c),
		// bnnr:   bnnrdao.New(c),
		adt:  adtdao.New(c),
		tag:  tagdao.New(c),
		arc:  arcdao.New(c),
		dbus: dbusdao.New(c),
		dyn:  dyndao.New(c),
		res:  resdao.New(c),
		// artic:   articledao.New(c),
		rg:   regiondao.New(c),
		cdao: carddao.New(c),
		act:  actdao.New(c),
		acc:  accdao.New(c),
		// relation
		reldao: reldao.New(c),
		loc:    locdao.New(c),
		client: httpx.NewClient(c.HTTPData),

		tick: time.Duration(c.Tick),

		jsonOn: false,

		logCh:     make(chan infoc, 1024),
		logFeedCh: make(chan interface{}, 1024),
		rcmmndCh:  make(chan recommend, 1024),
		logPath:   c.ShowLog,

		rcmmndOn:    false,
		rcmmndGroup: rcmmndGroup,
		rcmmndHosts: rcmmndHosts,
		// cpm percentage   0~100
		cpmNum:       0,
		cpmMid:       map[int64]struct{}{},
		cpmAll:       true,
		cpmRcmmndNum: 0,
		cpmRcmmndMid: map[int64]struct{}{},
		cpmRcmmndAll: true,
		adIsPost:     false,
		// region
		reRegionCache: map[int]*region.Region{},
		// ranking
		rankCache:     []*show.Item{},
		rankOseaCache: []*show.Item{},
		//card
		cardCache:       map[string][]*show.Show{},
		columnListCache: map[int]*card.ColumnList{},
		cardSetCache:    map[int64]*operate.CardSet{},
		eventTopicCache: map[int64]*operate.EventTopic{},
		// hot card
		hotTenTabCardCache: make(map[int][]*recmod.CardList),
		rankAidsCache:      []int64{},
		rankScoreCache:     map[int64]int64{},
		rankArchivesCache:  map[int64]*api.Arc{},
		// hotCache:           []*card.PopularCard{},
		rcmdCache:       []*card.PopularCard{},
		hottopicsCache:  []*clive.TopicHot{},
		rankCache2:      []*rank.Rank{},
		dynamicHotCache: []*clive.DynamicHot{},
		// prom
		pHit:  prom.CacheHit,
		pMiss: prom.CacheMiss,
	}
	var err error
	if s.creativeClient, err = creativeAPI.NewClient(nil); err != nil {
		panic("creativeGRPC not found!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
	}
	now := time.Now()
	s.loadCache(now)
	go s.cacheproc()
	go s.infocproc()
	go s.rcmmndproc()
	go s.infocfeedproc()
	return s
}

// cacheproc load all cache.
func (s *Service) cacheproc() {
	for {
		time.Sleep(s.tick)
		now := time.Now()
		s.loadCache(now)
	}
}

func (s *Service) loadCache(now time.Time) {
	s.loadRcmmndCache(now)
	s.loadRegionCache(now)
	s.loadBgmCache(now)
	s.loadLiveCache(now)
	s.loadBannerCahce()
	s.loadShowCache()
	s.loadShowTempCache()
	s.loadBlackCache()
	s.loadAuditCache()
	s.loadRegionListCache()
	s.loadRankAllCache()
	s.loadColumnListCache(now)
	s.loadCardCache(now)
	s.loadCardSetCache()
	// hot
	// s.loadPopularCard(now)
	s.loadHotTenTabAids()
	s.loadHotTopicCache()
	for i := 0; i < 10; i++ {
		s.loadHotTenMergeRcmdCache(i)
	}
	s.loadDynamicHotCache()
	s.loadEventTopicCache()
}

// SetRcmmndOn
func (s *Service) SetRcmmndOn(on bool) {
	s.rcmmndOn = on
}

// GetRcmmndOn
func (s *Service) RcmmndOn() bool {
	return s.rcmmndOn
}

// Close dao
func (s *Service) Close() error {
	return s.dao.Close()
}

// SetRcmmndGroup set rcmmnd group data.
func (s *Service) SetRcmmndGroup(m int64, g int) {
	tmp := map[int64]int{}
	tmp[m] = g
	for k, v := range s.rcmmndGroup {
		if k != m {
			tmp[k] = v
		}
	}
	s.rcmmndGroup = tmp
}

// GetRcmmndGroup get rcmmnd group data.
func (s *Service) GetRcmmndGroup() map[string]int {
	tmp := map[string]int{}
	for k, v := range s.rcmmndGroup {
		tmp[strconv.FormatInt(k, 10)] = v
	}
	return tmp
}

// SetRcmmndHost set rcmmnd host data.
func (s *Service) SetRcmmndHost(g int, hosts []string) {
	tmp := map[int][]string{}
	tmp[g] = hosts
	for k, v := range s.rcmmndHosts {
		if k != g {
			tmp[k] = v
		}
	}
	s.rcmmndHosts = tmp
}

// GetRcmmndHost get rcmmnd host data.
func (s *Service) GetRcmmndHost() map[string][]string {
	tmp := map[string][]string{}
	for k, v := range s.rcmmndHosts {
		tmp[strconv.Itoa(k)] = v
	}
	return tmp
}

// SetCpm percentage  0~100
func (s *Service) SetCpmNum(num int) {
	s.cpmNum = num
	if s.cpmNum < 0 {
		s.cpmNum = 0
	} else if s.cpmNum > 100 {
		s.cpmNum = 100
	}
}

// GetCpm percentage
func (s *Service) CpmNum() int {
	return s.cpmNum
}

// SetCpm percentage  0~100
func (s *Service) SetCpmMid(mid int64) {
	var mids = map[int64]struct{}{}
	mids[mid] = struct{}{}
	for mid, _ := range s.cpmMid {
		if _, ok := mids[mid]; !ok {
			mids[mid] = struct{}{}
		}
	}
	s.cpmMid = mids
}

// GetCpm percentage
func (s *Service) CpmMid() []int {
	var mids []int
	for mid, _ := range s.cpmMid {
		mids = append(mids, int(mid))
	}
	return mids
}

// SetCpm All
func (s *Service) SetCpmAll(isAll bool) {
	s.cpmAll = isAll
}

// GetCpm All
func (s *Service) CpmAll() int {
	if s.cpmAll {
		return 1
	}
	return 0
}

// RcmmndNum percentage
func (s *Service) RcmmndNum() int {
	return s.cpmRcmmndNum
}

// SetRcmmndNum percentage  0~100
func (s *Service) SetRcmmndNum(num int) {
	s.cpmRcmmndNum = num
	if s.cpmRcmmndNum < 0 {
		s.cpmRcmmndNum = 0
	} else if s.cpmRcmmndNum > 100 {
		s.cpmRcmmndNum = 100
	}
}

// CpmRcmmndMid Mid
func (s *Service) CpmRcmmndMid() []int {
	var mids []int
	for mid, _ := range s.cpmRcmmndMid {
		mids = append(mids, int(mid))
	}
	return mids
}

// SetCpmRcmmndMid Mid
func (s *Service) SetCpmRcmmndMid(mid int64) {
	var mids = map[int64]struct{}{}
	mids[mid] = struct{}{}
	for mid, _ := range s.cpmRcmmndMid {
		if _, ok := mids[mid]; !ok {
			mids[mid] = struct{}{}
		}
	}
	s.cpmRcmmndMid = mids
}

// CpmRcmmnd All
func (s *Service) CpmRcmmndAll() int {
	if s.cpmRcmmndAll {
		return 1
	}
	return 0
}

// SetCpmRcmmnd All
func (s *Service) SetCpmRcmmndAll(isAll bool) {
	s.cpmRcmmndAll = isAll
}

// SetIsPost Get or Post
func (s *Service) SetAdIsPost(isPost bool) {
	s.adIsPost = isPost
}

// IsPost Get or Post
func (s *Service) AdIsPost() int {
	if s.adIsPost {
		return 1
	}
	return 0
}