package service

import (
	"electricity_bill_calc/cache"
	"electricity_bill_calc/exceptions"
	"electricity_bill_calc/global"
	"electricity_bill_calc/logger"
	"electricity_bill_calc/model"
	"fmt"

	"github.com/google/uuid"
	"github.com/samber/lo"
	"github.com/uptrace/bun"
	"go.uber.org/zap"
)

type _MaintenanceFeeService struct {
	l *zap.Logger
}

var MaintenanceFeeService = _MaintenanceFeeService{
	l: logger.Named("Service", "maintenance"),
}

func (_MaintenanceFeeService) ListMaintenanceFees(pid []string) ([]model.MaintenanceFee, error) {
	if fees, _ := cache.RetreiveSearch[[]model.MaintenanceFee]("maintenance_fee", pid...); fees != nil {
		return *fees, nil
	}

	var (
		fees = make([]model.MaintenanceFee, 0)
		cond = global.DB.NewSelect().Model(&fees)
	)
	if len(pid) > 0 {
		cond = cond.Where("park_id in (?)", bun.In(pid))
	} else {
		return make([]model.MaintenanceFee, 0), exceptions.NewIllegalArgumentsError("必须给定所要请求的至少一个园区", "park_id")
	}

	ctx, cancel := global.TimeoutContext()
	defer cancel()

	err := cond.Order("created_at desc").Scan(ctx)
	if err != nil {
		return make([]model.MaintenanceFee, 0), err
	}
	relations := lo.Map(fees, func(f model.MaintenanceFee, _ int) string {
		return fmt.Sprintf("maintenance_fee:%s", f.Id)
	})
	relations = append(relations, "maintenance_fee", "park")

	cache.CacheSearch(fees, relations, "maintenance_fee", pid...)
	return fees, nil
}

func (_MaintenanceFeeService) CreateMaintenanceFeeRecord(fee model.MaintenanceFee) error {
	ctx, cancel := global.TimeoutContext()
	defer cancel()

	fee.Id = uuid.New().String()
	fee.Enabled = true
	_, err := global.DB.NewInsert().Model(&fee).Exec(ctx)
	if err != nil {
		return err
	}
	cache.AbolishRelation("maintenance_fee")
	return nil
}

func (_MaintenanceFeeService) ModifyMaintenanceFee(fee model.MaintenanceFee) error {
	ctx, cancel := global.TimeoutContext()
	defer cancel()

	res, err := global.DB.NewUpdate().Model(&fee).
		WherePK().
		Column("fee", "memo").
		Exec(ctx)
	if err != nil {
		if rows, _ := res.RowsAffected(); rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation(fmt.Sprintf("maintenance_fee:%s", fee.Id))
	return nil
}

func (_MaintenanceFeeService) ChangeMaintenanceFeeState(fid string, state bool) error {
	ctx, cancel := global.TimeoutContext()
	defer cancel()

	res, err := global.DB.NewUpdate().Model((*model.MaintenanceFee)(nil)).
		Where("id = ?", fid).
		Set("enabled = ?", state).
		Exec(ctx)
	if err != nil {
		if rows, err := res.RowsAffected(); rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation(fmt.Sprintf("maintenance_fee:%s", fid))
	return nil
}

func (_MaintenanceFeeService) DeleteMaintenanceFee(fid string) error {
	ctx, cancel := global.TimeoutContext()
	defer cancel()

	res, err := global.DB.NewDelete().Model((*model.MaintenanceFee)(nil)).
		Where("id = ?", fid).
		Exec(ctx)
	if err != nil {
		if rows, err := res.RowsAffected(); rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation(fmt.Sprintf("maintenance_fee:%s", fid))
	return nil
}

func (_MaintenanceFeeService) EnsureFeeBelongs(uid, mid string) (bool, error) {
	if has, _ := cache.CheckExists("maintenance_fee", mid, uid); has {
		return true, nil
	}

	ctx, cancel := global.TimeoutContext()
	defer cancel()

	parks := make([]model.Park, 0)
	err := global.DB.NewSelect().Model(&parks).
		Relation("MaintenanceFees").
		Where("p.user_id = ?", uid).
		Scan(ctx)
	if err != nil {
		return false, err
	}
	exists := lo.Reduce(parks, func(acc bool, elem model.Park, _ int) bool {
		for _, e := range elem.MaintenanceFees {
			if e.Id == mid {
				return acc || true
			}
		}
		return acc || false
	}, false)
	if !exists {
		return false, exceptions.NewNotFoundError("指定维护费所属园区未找到。")
	}
	cache.CacheExists([]string{fmt.Sprintf("maintenance_fee:%s", mid), "maintenance_fee", "park"}, "maintenance_fee", mid, uid)
	return exists, nil
}