package price

import (
	article2 "cls-server/internal/application/article"
	column2 "cls-server/internal/application/column"
	"cls-server/internal/domain/article"
	"cls-server/internal/domain/column"
	"cls-server/internal/domain/price"
	"cls-server/internal/domain/price_default"
	"cls-server/pkg/logger"
	"cls-server/pkg/util/page"
	"errors"
	"time"
	"xorm.io/builder"
)

var (
	ErrInvalidAmount   = errors.New("价格不能小于0")
	ErrInvalidType     = errors.New("无效的价格类型")
	ErrInvalidDuration = errors.New("无效的订阅时长")
)

// PriceService 价格管理服务
type PriceService struct {
	repo        price.PriceRepository
	articleRepo article.ArticleRepository
	columnRepo  column.ColumnRepository
	pdRepo      price_default.PriceDefaultRepository
	log         logger.Logger
}

// NewService 创建价格管理服务
func NewPriceService(repo price.PriceRepository, articleRepo article.ArticleRepository, columnRepo column.ColumnRepository, pdRepo price_default.PriceDefaultRepository, log logger.New) *PriceService {
	return &PriceService{
		repo:        repo,
		articleRepo: articleRepo,
		columnRepo:  columnRepo,
		pdRepo:      pdRepo,
		log:         log("cls:service:price"),
	}
}

func (s *PriceService) GetArticlePricePage(p *page.Page) error {
	conds := make([]builder.Cond, 0)
	//conds = append(conds, builder.Eq{"type": price.TypeArticle})
	// todo 加入付费文章条件
	conds = append(conds, builder.And(builder.Gt{"ctime": time.Now().AddDate(0, 0, -7).Unix()}))
	data := make([]*article.LianV1Article, 0)
	p.Content = &data
	err := s.articleRepo.Find(p, conds)
	if err != nil {
		s.log.Error(err)
		return err
	}
	ids := make([]uint64, 0, len(data))
	for _, v := range data {
		ids = append(ids, v.Id)
	}
	priceList, err := s.repo.FindPriceByIds(&ids, price.TypeArticle)
	if err != nil {
		s.log.Error(err)
		return err
	}

	asMap := make(map[uint64]*PriceDto, 0)
	for _, v := range *priceList {
		asMap[v.TargetID] = &PriceDto{
			ID:       v.ID,
			TargetID: v.TargetID,
			Amount:   v.Amount,
			Discount: v.Discount,
		}
	}

	dtoData := make([]*ArticlePriceDto, 0, len(data))
	for _, v := range data {
		t := time.Unix(v.Ctime, 0) // 秒数和纳秒数，0 表示没有纳秒部分

		dtoData = append(dtoData, &ArticlePriceDto{
			Article: &article2.ArticleDto{
				EventId:     v.Id,
				Title:       v.Title,
				Class:       article2.GetClassNameById(v.Type),
				Stocks:      v.Stocks,
				ReleaseDate: t.Format("2006-01-02"),
				ReleaseTime: t.Format("15:04"),
				Brief:       v.Brief,
				Content:     v.Content,
			},
			Price: asMap[v.Id],
		})
	}
	p.Content = &dtoData
	return nil
}

func (s *PriceService) GetColumnPricePage(p *page.Page) error {
	conds := make([]builder.Cond, 0)
	data := make([]*column.Column, 0)
	p.Content = &data
	err := s.columnRepo.FindAll(p, conds)
	if err != nil {
		s.log.Error(err.Error())
	}
	ids := make([]uint64, 0, len(data))
	for _, v := range data {
		ids = append(ids, v.ID)
	}
	priceList, err := s.repo.FindPriceByIds(&ids, price.TypeColumn)
	if err != nil {
		s.log.Error(err)
		return err
	}
	asMap := make(map[uint64]*PriceDto, 0)
	for _, v := range *priceList {
		asMap[v.TargetID] = &PriceDto{
			ID:                v.ID,
			TargetID:          v.TargetID,
			FirstMontDiscount: v.FirstMontDiscount,
			OneMonthPrice:     v.OneMonthPrice,
			ThreeMonthsPrice:  v.ThreeMonthsPrice,
			SixMonthsPrice:    v.SixMonthsPrice,
			OneYearPrice:      v.OneYearPrice,
			Discount:          v.Discount,
		}
	}

	dtoData := make([]*ColumnPriceDto, 0, len(data))
	for _, v := range data {
		dtoData = append(dtoData, &ColumnPriceDto{
			Column: &column2.ColumnDto{
				ID:          v.ID,
				Title:       v.Title,
				Brief:       v.Brief,
				Cover:       v.Cover,
				AuthorID:    v.AuthorID,
				ArticleNum:  v.ArticleNum,
				FollowNum:   v.FollowNum,
				PurchaseNum: v.PurchaseNum,
				CreatedAt:   v.CreatedAt,
			},
			Price: asMap[v.ID],
		})
	}
	p.Content = &dtoData
	return err
}

// DeletePrice 删除价格记录
func (s *PriceService) DeletePrice(id uint64) error {
	return s.repo.Delete(id)
}

func (s *PriceService) UpdatePrice(dto *PriceDto) error {
	if err := dto.Validate(); err != nil {
		return err
	}
	var err error
	articlePrice := &price.Price{
		TargetID: dto.TargetID,
		Type:     dto.Type,
		Discount: dto.Discount,
	}
	if dto.ID < 1 {

		if dto.Type == price.TypeArticle {
			articlePrice.Amount = dto.Amount
		} else {
			articlePrice.OneMonthPrice = dto.OneMonthPrice
			articlePrice.ThreeMonthsPrice = dto.ThreeMonthsPrice
			articlePrice.SixMonthsPrice = dto.SixMonthsPrice
			articlePrice.OneYearPrice = dto.OneYearPrice
			articlePrice.FirstMontDiscount = dto.FirstMontDiscount
			articlePrice.AdminID = dto.AdminID
		}
		err = s.repo.Save(articlePrice)
		if err != nil {
			s.log.Error(err)
		}
	} else {
		if dto.Type == price.TypeArticle {
			articlePrice.Amount = dto.Amount
		} else {
			articlePrice.OneMonthPrice = dto.OneMonthPrice
			articlePrice.ThreeMonthsPrice = dto.ThreeMonthsPrice
			articlePrice.SixMonthsPrice = dto.SixMonthsPrice
			articlePrice.OneYearPrice = dto.OneYearPrice
			articlePrice.FirstMontDiscount = dto.FirstMontDiscount
			articlePrice.AdminID = dto.AdminID
		}
		err = s.repo.Update(articlePrice)
		if err != nil {
			s.log.Error(err)
		}
	}

	return err

}

func (s *PriceService) GetPriceDefault() (*PriceDefaultDto, error) {
	data, err := s.pdRepo.Get()
	if err != nil {
		s.log.Error(err.Error())
	}
	return &PriceDefaultDto{
		Id:                data.Id,
		Amount:            data.Amount,
		FirstMontDiscount: data.FirstMontDiscount,
		OneMonthPrice:     data.OneMonthPrice,
		ThreeMonthsPrice:  data.ThreeMonthsPrice,
		SixMonthsPrice:    data.SixMonthsPrice,
		OneYearPrice:      data.OneYearPrice,
		Discount:          data.Discount,
	}, err
}

func (s *PriceService) UpdatePriceDefault(pdDto *PriceDefaultDto) error {
	err := s.pdRepo.Save(&price_default.PriceDefault{
		Id:                pdDto.Id,
		Amount:            pdDto.Amount,
		FirstMontDiscount: pdDto.FirstMontDiscount,
		OneMonthPrice:     pdDto.OneMonthPrice,
		ThreeMonthsPrice:  pdDto.ThreeMonthsPrice,
		SixMonthsPrice:    pdDto.SixMonthsPrice,
		OneYearPrice:      pdDto.OneYearPrice,
		Discount:          pdDto.Discount,
	})
	if err != nil {
		s.log.Error(err)
	}
	return err
}