package service

import (
	"context"
	"database/sql"
	"fmt"
	"time"

	"go-common/app/admin/main/tv/model"
	"go-common/library/ecode"
	"go-common/library/log"
	"go-common/library/xstr"

	"github.com/jinzhu/gorm"
)

// ugcLabels refreshes ugc labels
func (s *Service) ugcLabels() (err error) {
	var firstTps = s.firstTps()
	if err = s.ugcTpLabel(firstTps); err != nil {
		log.Error("ugcTpLabel Err %v", err)
		return
	}
	if err = s.ugcPubLabel(firstTps); err != nil {
		log.Error("ugcPubLabel Tps %v, Err %v", firstTps, err)
	}
	return
}

func (s *Service) ugcPubLabel(firstTps []int32) (err error) {
	var (
		exist bool
		cfg   = s.c.Cfg.RefLabel
	)
	for _, v := range firstTps { // check and create pub_time label
		pubtCore := &model.LabelCore{
			CatType:   model.UgcLabel,
			Category:  v,
			Param:     model.ParamUgctime,
			Value:     cfg.AllValue,
			Valid:     1,
			ParamName: cfg.UgcTime,
			Name:      cfg.AllName,
		}
		if exist, err = s.labelExist(pubtCore); err != nil {
			return
		}
		if !exist {
			if err = s.DB.Create(&model.LabelDB{LabelCore: *pubtCore}).Error; err != nil {
				log.Error("ugcLabels Pubtime All, Create Err %v", err)
				return
			}
		}
		time.Sleep(20 * time.Millisecond)
	}
	return
}

func (s *Service) firstTps() (tps []int32) {
	for _, v := range s.ArcTypes {
		if v.Pid == 0 {
			tps = append(tps, v.ID)
		}
	}
	return
}

func (s *Service) ugcTpLabel(firstTps []int32) (err error) {
	var (
		exist bool
		cfg   = s.c.Cfg.RefLabel
	)
	for _, v := range firstTps {
		extCore := &model.LabelCore{
			CatType:   model.UgcLabel,
			Param:     model.ParamTypeid,
			Valid:     1,
			Category:  v,
			Value:     cfg.AllValue,
			ParamName: cfg.UgcType,
			Name:      cfg.AllName,
		}
		if exist, err = s.labelExist(extCore); err != nil {
			return
		}
		if !exist {
			if err = s.DB.Create(&model.LabelDB{LabelCore: *extCore}).Error; err != nil {
				log.Error("ugcLabels ArcTypeID %d, Create ALL Label Err %v", v, err)
				return
			}
		}
	}
	for _, v := range s.ArcTypes {
		if v.Pid == 0 { // if first level type, we check the "ALL" label
			continue
		}
		extCore := &model.LabelCore{
			CatType:  model.UgcLabel,
			Param:    model.ParamTypeid,
			Valid:    1,
			Category: v.Pid,
			Value:    fmt.Sprintf("%d", v.ID),
		}
		if exist, err = s.labelExist(extCore); err != nil {
			return
		}
		if !exist {
			label := model.LabelDB{}
			label.FromArcTp(v, s.c.Cfg.RefLabel.UgcType)
			if err = s.DB.Create(&label).Error; err != nil {
				log.Error("ugcLabels ArcTypeID %d, Create Err %v", v.ID, err)
				return
			}
			time.Sleep(20 * time.Millisecond)
		}
	}
	return
}

// labelsExist distinguishes whether the ids are existing
func (s *Service) labelsExist(ids []int64) (err error) {
	var (
		labels []*model.LabelDB
		idmap  = make(map[int64]int)
	)
	if err = s.DB.Where(fmt.Sprintf("id IN (%s)", xstr.JoinInts(ids))).Where("deleted = 0").Find(&labels).Error; err != nil {
		log.Error("labelsExist Ids %v, Err %v", ids, err)
		return
	}
	if len(labels) >= len(ids) {
		return
	}
	for _, v := range labels {
		idmap[v.ID] = 1
	}
	for _, v := range ids {
		if _, ok := idmap[v]; !ok {
			log.Warn("labelsExist ids %v, not exist %d", ids, v)
			return ecode.RequestErr
		}
	}
	return
}

func (s *Service) labelExist(req *model.LabelCore) (exist bool, err error) {
	var (
		label = model.LabelDB{}
		db    = s.DB.Model(label).Where("deleted = 0")
	)
	if req.ID != 0 {
		db = db.Where("id = ?", req.ID)
	}
	if req.Category != 0 {
		db = db.Where("category = ?", req.Category)
	}
	if req.CatType != 0 {
		db = db.Where("cat_type = ?", req.CatType)
	}
	if req.Param != "" {
		db = db.Where("param = ?", req.Param)
	}
	if req.Value != "" {
		db = db.Where("value = ?", req.Value)
	}
	if req.Name != "" {
		db = db.Where("name = ?", req.Name)
	}
	if err = db.First(&label).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			err = nil
			return
		}
		log.Error("labelExist V %v, Err %v", req, err)
		return
	}
	if label.ID > 0 {
		exist = true
	}
	return
}

func (s *Service) pgcLabels() (err error) {
	var (
		result *model.PgcCond
		exist  bool
	)
	for _, cat := range s.c.Cfg.SupportCat.PGCTypes {
		if result, err = s.dao.PgcCond(context.Background(), cat); err != nil {
			log.Error("PgcCond Cat %d, Err %v", cat, err)
			return
		}
		for _, cond := range result.Filter {
			if len(cond.Value) == 0 {
				continue
			}
			for _, v := range cond.Value {
				if exist, err = s.labelExist(&model.LabelCore{
					CatType:  model.PgcLabel,
					Category: cat,
					Param:    cond.ID,
					Value:    v.ID,
				}); err != nil {
					return
				}
				if exist {
					continue
				}
				label := model.LabelDB{}
				label.FromPgcCond(v, cond, cat)
				if err = s.DB.Create(&label).Error; err != nil {
					log.Error("pgcLabels Param %s, Cond %v Create Err %v", cond.ID, v, err)
					return
				}
				time.Sleep(20 * time.Millisecond)
			}
		}
	}
	return
}

// AddUgcTm adds time label for ugc
func (s *Service) AddUgcTm(tm *model.UgcTime) (err error) {
	var (
		exist bool
		timeV = tm.TimeV()
	)
	if exist, err = s.labelExist(&model.LabelCore{
		Category: tm.Category,
		Param:    model.ParamUgctime,
		Name:     tm.Name,
	}); err != nil {
		return
	}
	if exist {
		err = ecode.TvLabelExist
		return
	}
	label := model.LabelDB{}
	label.FromUgcTime(tm, s.c.Cfg.RefLabel.UgcTime)
	if err = s.DB.Create(&label).Error; err != nil {
		log.Error("ugcTimeLabel Time %s, Create Err %v", timeV, err)
	}
	return
}

// EditUgcTm edits a time label by name
func (s *Service) EditUgcTm(tm *model.EditUgcTime) (err error) {
	var exist bool
	if exist, err = s.labelExist(&model.LabelCore{
		ID: tm.ID,
	}); err != nil {
		return
	}
	if !exist {
		err = ecode.NothingFound
		return
	}
	if err = s.DB.Model(&model.LabelDB{}).Where("id = ?", tm.ID).Update(map[string]string{
		"name":  tm.Name,
		"value": tm.TimeV(),
	}).Error; err != nil {
		log.Error("ugcTimeLabel LabelID %d, Update Err %v", tm.ID, err)
	}
	return
}

// ActLabels act on labels
func (s *Service) ActLabels(ids []int64, act int) (err error) {
	if err = s.labelsExist(ids); err != nil {
		return
	}
	if err = s.DB.Model(&model.LabelDB{}).Where(fmt.Sprintf("id IN (%s)", xstr.JoinInts(ids))).Update(map[string]int{
		"valid": act,
	}).Error; err != nil {
		log.Error("ActLabels LabelID %s, Update Err %v", ids, err)
	}
	return
}

// DelLabels deletes labels
func (s *Service) DelLabels(ids []int64) (err error) {
	var exist bool
	for _, v := range ids {
		if exist, err = s.labelExist(&model.LabelCore{
			ID:      v,
			CatType: model.UgcLabel,
			Param:   model.ParamUgctime,
		}); err != nil {
			return
		}
		if !exist {
			log.Warn("DelLabels IDs %v, ID not exist %d", ids, v)
			return ecode.RequestErr
		}
	}
	if err = s.DB.Exec(fmt.Sprintf("UPDATE tv_label SET deleted = 1 WHERE id IN (%s)", xstr.JoinInts(ids))).Error; err != nil {
		log.Error("DelLabels LabelID %s, Update Err %v", ids, err)
	}
	return
}

// DynamicLabels picks the defined pgc label types
func (s *Service) labelTypes() (tps []*model.TpLabel, err error) {
	var rows *sql.Rows
	//  select category, param , param_name from tv_label where deleted = 0 and cat_type = 1 group by category,param
	if rows, err = s.DB.Model(&model.LabelDB{}).Where("deleted = 0").
		Where("cat_type = ?", model.PgcLabel).Select("category, param, param_name").Group("category,param").Rows(); err != nil {
		log.Error("labelTypes rows Err %v", err)
		return
	}
	defer rows.Close()
	for rows.Next() {
		var cont = &model.TpLabel{}
		if err = rows.Scan(&cont.Category, &cont.Param, &cont.ParamName); err != nil {
			log.Error("rows.Scan error(%v)", err)
			return
		}
		tps = append(tps, cont)
	}
	if err = rows.Err(); err != nil {
		log.Error("labelTypes rows Err %v", err)
	}
	return
}

func (s *Service) loadLabel() (err error) {
	var (
		newTps = make(map[int][]*model.TpLabel)
		labels []*model.TpLabel
	)
	if labels, err = s.labelTypes(); err != nil {
		log.Error("labelTypes err %v", err)
		time.Sleep(time.Duration(10 * time.Second))
		return
	}
	for _, v := range labels {
		if lbs, ok := newTps[v.Category]; ok {
			newTps[v.Category] = append(lbs, v)
		} else {
			newTps[v.Category] = append([]*model.TpLabel{}, v)
		}
	}
	if len(newTps) > 0 {
		s.labelTps = newTps
	}
	return
}

// LabelTp returns the category's label types
func (s *Service) LabelTp(category int) (lbs []*model.TpLabel, err error) {
	var ok bool
	if lbs, ok = s.labelTps[category]; !ok {
		err = ecode.RequestErr
	}
	return
}

// PickLabels picks ugc labels
func (s *Service) PickLabels(req *model.ReqLabel, catType int) (data []*model.LabelList, err error) {
	var (
		db = s.DB.Model(&model.LabelDB{}).
			Where("param = ?", req.Param).
			Where("category = ?", req.Category).
			Where("deleted = 0").
			Where("cat_type = ?", catType)
		labels []*model.LabelDB
	)
	if req.Title != "" {
		db = db.Where("name LIKE ?", "%"+req.Title+"%")
	}
	if req.ID != 0 {
		db = db.Where("id = ?", req.ID)
	}
	if err = db.Order("position ASC").Find(&labels).Error; err != nil {
		log.Error("PickLabels Req %v, Err %v", req, err)
	}
	for _, v := range labels {
		data = append(data, v.ToList())
	}
	return
}

// EditLabel edits a pgc label
func (s *Service) EditLabel(id int64, name string) (err error) {
	var exist bool
	if exist, err = s.labelExist(&model.LabelCore{
		ID: id,
	}); err != nil {
		return
	}
	if !exist {
		err = ecode.NothingFound
		return
	}
	if err = s.DB.Model(&model.LabelDB{}).Where("id = ?", id).Update(map[string]string{
		"name": name,
	}).Error; err != nil {
		log.Error("EditLabel LabelID %d, Update Err %v", id, err)
	}
	return
}

// PubLabel publish label's order
func (s *Service) PubLabel(ids []int64) (err error) {
	if len(ids) == 0 {
		return
	}
	var (
		labels   []*model.LabelDB
		position = 1
		tx       = s.DB.Begin()
		labelMap = make(map[int64]*model.LabelDB, len(ids))
	)
	if err = s.DB.Where(fmt.Sprintf("id IN (%s)", xstr.JoinInts(ids))).Find(&labels).Error; err != nil {
		log.Error("PubLabel Ids %v, Err %v", ids, err)
		return
	}
	if len(labels) == 0 {
		err = ecode.NothingFound
		return
	}
	for _, v := range labels {
		labelMap[v.ID] = v
	}
	for _, id := range ids {
		lbl, ok := labelMap[id]
		if !ok {
			err = ecode.RequestErr
			log.Warn("PubLabel Id %d Not found", id)
			return
		}
		if !lbl.SameType(labels[0]) {
			log.Error("PubLabel Id %d FirstLabel ID %d, Not same type", lbl.ID, labels[0].ID)
			err = ecode.RequestErr
			tx.Rollback()
			return
		}
		if err = tx.Model(&model.LabelDB{}).Where("id = ?", lbl.ID).Update(map[string]int{"position": position}).Error; err != nil {
			log.Error("PubLabel ID %d, Err %v", lbl.ID, err)
			tx.Rollback()
			return
		}
		position = position + 1
	}
	tx.Commit()
	return
}