package dao

import (
	"errors"
	"fmt"
	"yintai-api/app/common/model"

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

type News struct {
	db *gorm.DB
}

func NewNews(db ...*gorm.DB) *News {
	return &News{db: getDB(db...)}
}

func (r *News) TableName() string {
	return "yt_news"
}

func (r *News) Create(m *model.News) error {
	return r.db.Table(r.TableName()).Create(m).Error
}

func (r *News) Update(m *model.News) error {
	return r.db.Table(r.TableName()).Save(m).Error
}

func (r *News) Delete(id int64) error {
	return r.db.Table(r.TableName()).Where("id = ?", id).Delete(&News{}).Error
}

func (r *News) Get(id int64) (*model.News, error) {
	var res model.News
	if err := r.db.Table(r.TableName()).Where("id = ?", id).First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &res, nil
}

func (r *News) Exists(id int64) (bool, error) {
	var count int64
	if err := r.db.Table(r.TableName()).Where("id = ?", id).Count(&count).Error; err != nil {
		return false, err
	}
	return count > 0, nil
}

func (r *News) List(lang, title, content, publishTime string, categoryID, pinned int64, page, size int, sort string) ([]*model.NewsPage, int64, error) {
	var list []*model.NewsPage
	var count int64
	tx := r.db.Table(r.TableName() + " AS p ")
	tx = tx.Joins(fmt.Sprintf("LEFT JOIN %s AS t ON p.id = t.news_id ", NewNewsTranslations().TableName()))
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s l ON l.biz_id = p.id AND l.type = ?", NewCategoryRelation().TableName()), model.CateTypeNews)
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s c ON c.id = l.category_id", NewCategory().TableName()))
	if lang != "" {
		tx = tx.Where("t.lang = ?", lang)
	}

	if title != "" {
		tx = tx.Where("t.title LIKE ?", "%"+title+"%")
	}

	if content != "" {
		tx = tx.Where("t.content LIKE ?", "%"+content+"%")
	}

	if publishTime != "" {
		tx = tx.Where("t.publish_time = ?", publishTime)
	}

	if cast.ToInt64(categoryID) != 0 {
		tx = tx.Where("c.id = ?", cast.ToInt64(categoryID))
	}

	if pinned > 0 {
		tx = tx.Where("p.pinned = ?", pinned)
	}

	if err := tx.Count(&count).Error; err != nil {
		return nil, 0, err
	}

	if sort != "" {
		tx = tx.Order(sort)
	} else {
		tx = tx.Order("pinned desc,weight desc,create_time desc")
	}

	if err := tx.Offset((page - 1) * size).Limit(size).Select("p.*,t.*,c.name as category_name,c.name_en as category_en,c.id as category_id").Find(&list).Error; err != nil {
		return nil, 0, err
	}

	return list, count, nil
}

func (r *News) GetLang(id int64, lang string) (*model.NewsPage, error) {
	var res *model.NewsPage
	tx := r.db.Table(r.TableName() + " AS p ")
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s AS t ON p.id = t.news_id ", NewNewsTranslations().TableName()))
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s l ON l.biz_id = p.id AND l.type = ?", NewCategoryRelation().TableName()), model.CateTypeNews)
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s c ON c.id = l.category_id", NewCategory().TableName()))
	tx = tx.Where("p.id = ?", id)
	tx = tx.Where("t.lang = ?", lang)

	if err := tx.Select("p.*,t.*,c.name as category_name,c.name_en as category_en,c.id as category_id").First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}

	return res, nil
}

func (r *News) GetN(categoryID int64, lang string, page, size int, sort string) ([]*model.NewsPage, error) {
	var res []*model.NewsPage
	tx := r.db.Table(r.TableName() + " AS p ")
	tx = tx.Joins(fmt.Sprintf("LEFT JOIN %s AS t ON p.id = t.news_id ", NewNewsTranslations().TableName()))
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s l ON l.biz_id = p.id AND l.type = ?", NewCategoryRelation().TableName()), model.CateTypeNews)
	tx = tx.Joins(fmt.Sprintf(" LEFT JOIN %s c ON c.id = l.category_id", NewCategory().TableName()))
	tx = tx.Where("c.id = ?", cast.ToInt64(categoryID))
	tx = tx.Where("t.lang = ?", lang)
	if sort != "" {
		tx = tx.Order(sort)
	} else {
		tx = tx.Order("pinned desc,weight desc,create_time desc")
	}
	tx = tx.Offset((page - 1) * size).Limit(size)
	if err := tx.Select("p.*,t.title").Find(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return res, nil
}

func (r *News) PureAll() ([]*model.News, error) {
	var res []*model.News
	tx := r.db.Table(r.TableName()).Find(&res)
	if tx.Error != nil {
		if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, tx.Error
	}

	return res, nil
}

func (r *News) Incr(id int64, counts ...int) error {
	count := 1
	if len(counts) > 0 {
		count = counts[0]
	}

	tx := r.db.Table(r.TableName()).Where("id = ?", id).Updates(map[string]any{"count": gorm.Expr("count + ?", count)})
	if tx.Error != nil {
		return tx.Error
	}

	if tx.RowsAffected == 0 {
		return gorm.ErrRecordNotFound
	}

	return nil
}