package controller

import (
	"context"

	"video-factory/shortdrama/consts/public"
	"video-factory/shortdrama/dao"
	"video-factory/shortdrama/model/dto"
	"video-factory/shortdrama/model/entity"
	"video-factory/shortdrama/service"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"
)

type agent struct{}

var Agent = new(agent)

type createAgentRes struct {
	Id int64 `json:"id"`
}

func (c *agent) Create(ctx context.Context, req *dto.CreateAgentReq) (res *createAgentRes, err error) {
	user, err := service.AuthService.CreateAgent(ctx, req.Username, req.Password, req.Phone, req.Name, req.Province, req.Region, req.RegionProtected)
	if err != nil {
		return nil, err
	}
	return &createAgentRes{Id: user.Id}, nil
}

func (c *agent) List(ctx context.Context, req *dto.ListAgentReq) (res *dto.ListAgentRes, err error) {
	m := g.DB().Model(public.TableNameUser+" u").
		LeftJoin(public.TableNameAgentProfile+" ap", "ap.user_id = u.id").
		Where("u.role", "agent")
	if req.Keyword != "" {
		m = m.Where("u.name LIKE ? OR u.username LIKE ? OR u.phone LIKE ?", "%"+req.Keyword+"%", "%"+req.Keyword+"%", "%"+req.Keyword+"%")
	}
	if req.Phone != "" {
		m = m.Where("u.phone LIKE ?", "%"+req.Phone+"%")
	}
	if req.Province != "" {
		m = m.Where("u.province = ?", req.Province)
	}
	if req.Region != "" {
		m = m.Where("u.region = ?", req.Region)
	}
	if req.ExpiredAtFrom != "" {
		m = m.Where("ap.expired_at >= ?", req.ExpiredAtFrom)
	}
	if req.ExpiredAtTo != "" {
		m = m.Where("ap.expired_at <= ?", req.ExpiredAtTo)
	}
	total, err := m.Count()
	if err != nil {
		return nil, err
	}

	type agentRow struct {
		Id              int64       `orm:"id"`
		Username        string      `orm:"username"`
		Phone           string      `orm:"phone"`
		Name            string      `orm:"name"`
		Province        string      `orm:"province"`
		Region          string      `orm:"region"`
		ExpiredAt       *gtime.Time `orm:"expired_at"`
		RegionProtected int         `orm:"region_protected"`
		MaxCustomers    int         `orm:"max_customers"`
	}
	var rows []*agentRow
	err = m.Fields(
		"u.id", "u.username", "u.phone", "u.name", "u.province", "u.region",
		"ap.expired_at", "ap.region_protected", "ap.max_customers",
	).Page(req.Page, req.PageSize).OrderAsc("u.id").Scan(&rows)
	if err != nil {
		return nil, err
	}

	list := make([]*dto.ListAgentItem, len(rows))
	for i, r := range rows {
		list[i] = &dto.ListAgentItem{
			User: &entity.User{
				Id:        r.Id,
				Username:  r.Username,
				Phone:     r.Phone,
				Name:      r.Name,
				Province:  r.Province,
				Region:    r.Region,
				ExpiredAt: r.ExpiredAt,
			},
			RegionProtected: r.RegionProtected,
			MaxCustomers:    r.MaxCustomers,
		}
	}
	return &dto.ListAgentRes{List: list, Total: total, Page: req.Page, PageSize: req.PageSize}, nil
}

func (c *agent) Update(ctx context.Context, req *dto.UpdateAgentReq) (res *struct{}, err error) {
	if req.Name != "" {
		m := g.Map{
			"name":   req.Name,
			"region": req.Region,
		}
		if req.Phone != "" {
			m["phone"] = req.Phone
		}
		if req.Province != "" {
			m["province"] = req.Province
		}
		if err := dao.User.UpdateFields(ctx, req.Id, m); err != nil {
			return nil, err
		}
	}

	// 确保 agent_profile 存在
	profile, _ := dao.AgentProfile.Get(ctx, req.Id)
	if profile == nil {
		maxCustomers := 0
		if pricing, _ := dao.RegionPricing.GetByRegion(ctx, req.Region, 0); pricing != nil {
			maxCustomers = pricing.MaxCustomers
		}
		_ = dao.AgentProfile.Save(ctx, &entity.AgentProfile{
			UserId:          req.Id,
			MaxCustomers:    maxCustomers,
			Renewals:        0,
			ExpiredAt:       gtime.Now().AddDate(1, 0, 0),
			RegionProtected: false,
		})
	}

	return nil, nil
}

func (c *agent) Renew(ctx context.Context, req *dto.RenewAgentReq) (res *struct{}, err error) {
	return nil, service.AuthService.RenewAgent(ctx, req.AgentId)
}

func (c *agent) CreateRenewOrder(ctx context.Context, req *dto.CreateRenewOrderReq) (res *dto.CreateRenewOrderRes, err error) {
	order, err := service.PaymentService.CreateRenewalOrder(ctx, req.AgentId, req.Duration, req.PricingId)
	if err != nil {
		return nil, err
	}
	if err := service.PaymentService.ConfirmOffline(ctx, order.OrderNo); err != nil {
		return nil, err
	}
	return &dto.CreateRenewOrderRes{
		OrderNo: order.OrderNo,
		Amount:  order.Amount,
		Status:  "success",
	}, nil
}

type getAgentDetailRes struct {
	User    *entity.User         `json:"user"`
	Profile *entity.AgentProfile `json:"profile"`
}

func (c *agent) ListRenewals(ctx context.Context, req *dto.ListRenewalsReq) (res *dto.ListRenewalsRes, err error) {
	orders, err := dao.PaymentOrder.ListByUserAndType(ctx, req.AgentId, "renewal")
	if err != nil {
		return nil, err
	}
	list := make([]*dto.RenewalRecord, len(orders))
	for i, o := range orders {
		paidAt := ""
		if o.PaidAt != nil {
			paidAt = o.PaidAt.Format("Y-m-d H:i:s")
		}
		createdAt := ""
		if o.CreatedAt != nil {
			createdAt = o.CreatedAt.Format("Y-m-d H:i:s")
		}
		list[i] = &dto.RenewalRecord{
			Id:        o.Id,
			OrderNo:   o.OrderNo,
			Amount:    o.Amount,
			Channel:   o.Channel,
			Status:    o.Status,
			Subject:   o.Subject,
			PaidAt:    paidAt,
			CreatedAt: createdAt,
		}
	}
	return &dto.ListRenewalsRes{List: list}, nil
}

func (c *agent) Get(ctx context.Context, req *struct{ Id int64 }) (res *getAgentDetailRes, err error) {
	user, err := dao.User.GetOne(ctx, req.Id)
	if err != nil || user == nil {
		return nil, err
	}
	profile, _ := dao.AgentProfile.Get(ctx, req.Id)
	return &getAgentDetailRes{User: user, Profile: profile}, nil
}