package service

import (
	"encoding/json"
	"slices"
	"strings"
	"time"
	"yintai-api/app/admin/request"
	"yintai-api/app/common/consts"
	"yintai-api/app/common/dao"
	err2 "yintai-api/app/common/err"
	"yintai-api/app/common/model"
	"yintai-api/base/global"

	"github.com/smbrave/goutil"
	"github.com/spf13/cast"
	"gorm.io/gorm"
)

type News struct{}

func (r *News) Create(req request.NewsCreate) int64 {
	images := make(map[string][]string)
	for sourceType, imgs := range req.CoverResource {
		images[sourceType] = Images(imgs)
	}

	m := new(model.News)
	m.CoverImages = goutil.EncodeJSON(images)
	m.CoverShow = req.CoverShow
	m.Count = 0
	m.CreateTime = time.Now().Unix()
	m.Weight = cast.ToInt64(req.Weight)
	m.Pinned = cast.ToInt64(req.Pinned) % 2

	ms := make([]*model.NewsTranslations, 0)
	for lang, trans := range req.Trans {
		lang = strings.ToUpper(lang)
		if !slices.Contains(consts.LangSupport, lang) {
			continue
		}
		ms = append(ms, &model.NewsTranslations{
			Lang:        lang,
			Title:       trans.Title,
			PublishTime: trans.PublishTime,
			Content:     trans.Content,
		})
	}

	err := global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err := dao.NewNews(tx).Create(m); err != nil {
			return err
		}

		for _, trans := range ms {
			trans.NewsID = m.ID
			if err := dao.NewNewsTranslations(tx).Create(trans); err != nil {
				return err
			}
		}

		if err := BizCateCreate(tx, m.ID, cast.ToInt64(req.CategoryID), model.CateTypeNews); err != nil {
			return err
		}

		return nil
	})
	if err != nil {
		err2.DbErr(err)
	}

	return m.ID
}

func (r *News) Update(req request.NewsUpdate) {
	m, err := dao.NewNews().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	images := make(map[string][]string)
	_ = json.Unmarshal([]byte(m.CoverImages), &images)

	if req.CoverResource != nil {
		for sourceType, imgs := range req.CoverResource {
			images[sourceType] = Images(imgs)
		}
		m.CoverImages = goutil.EncodeJSON(images)
	}

	if m.CoverShow != "" {
		m.CoverShow = req.CoverShow
	}

	if weight := cast.ToInt64(req.Weight); weight != m.Weight {
		m.Weight = weight
	}

	if pinned := cast.ToInt64(req.Pinned); pinned != m.Pinned {
		m.Pinned = pinned
	}

	m.UpdateTime = time.Now().Unix()

	ms := make([]*model.NewsTranslations, 0)
	for lang, trans := range req.Trans {
		lang = strings.ToUpper(lang)
		if !slices.Contains(consts.LangSupport, lang) {
			continue
		}
		t, err := dao.NewNewsTranslations().GetByMaster(m.ID, lang)
		if err != nil {
			err2.DbErr(err)
		}

		if t == nil {
			t = new(model.NewsTranslations)
		}
		if trans.Title != "" {
			t.Title = trans.Title
		}

		if trans.PublishTime != "" {
			t.PublishTime = trans.PublishTime
		}

		if trans.Content != "" {
			t.Content = trans.Content
		}

		ms = append(ms, t)
	}

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = dao.NewNews(tx).Update(m); err != nil {
			return err
		}

		for _, trans := range ms {
			trans.NewsID = m.ID
			if err = dao.NewNewsTranslations(tx).Update(trans); err != nil {
				return err
			}
		}

		if cast.ToInt64(req.CategoryID) > 0 {
			if err = BizCateUpdate(tx, m.ID, cast.ToInt64(req.CategoryID), model.CateTypeNews); err != nil {
				return err
			}

		}

		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return
}

func (r *News) Delete(req request.NewsDelete) {
	m, err := dao.NewNews().Get(cast.ToInt64(req.ID))
	if err != nil {
		err2.DbErr(err)
	}

	if m == nil {
		err2.NotEsxErr()
		return
	}

	err = global.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = dao.NewNews(tx).Delete(m.ID); err != nil {
			return err
		}

		if err = dao.NewNewsTranslations(tx).Delete(m.ID); err != nil {
			return err
		}
		return nil
	})

	if err != nil {
		err2.DbErr(err)
	}

	return
}

func (r *News) List(req request.NewsList) (any, int64) {
	req.Pagination()
	lists, count, err := dao.NewNews().List(req.Lang, req.Title, req.Content, req.PublishTime, cast.ToInt64(req.CategoryID), -1, req.Page, req.Size, req.Sort)
	if err != nil {
		err2.DbErr(err)
	}

	res := make([]map[string]any, 0)
	for _, list := range lists {
		res = append(res, list.Format())
	}

	return res, count
}

func (r *News) Get(req request.NewsDelete) any {
	res := make(map[string]any)
	for _, lang := range consts.LangSupport {
		x, err := dao.NewNews().GetLang(cast.ToInt64(req.ID), lang)
		if err != nil {
			err2.DbErr(err)
		}

		if x == nil {
			res[lang] = make(map[string]any)
			continue
		}

		res[lang] = x.Format()
	}

	return res
}