package service

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

	"github.com/google/uuid"
	"xorm.io/builder"
)

type _MaintenanceFeeService struct{}

var MaintenanceFeeService _MaintenanceFeeService

func (_MaintenanceFeeService) ListMaintenanceFees(pid []string) ([]model.MaintenanceFee, error) {
	cond := builder.NewCond()
	if len(pid) > 0 {
		cond = cond.And(builder.Eq{"park_id": pid})
	} else {
		return make([]model.MaintenanceFee, 0), exceptions.NewIllegalArgumentsError("必须给定所要请求的至少一个园区", "park_id")
	}
	if fees, _ := cache.RetreiveSearch[[]model.MaintenanceFee]("maintenance_fee", pid...); fees != nil {
		return *fees, nil
	}
	var fees = make([]model.MaintenanceFee, 0)
	err := global.DBConn.Where(cond).Desc("created_at").Find(&fees)
	if err != nil {
		return make([]model.MaintenanceFee, 0), err
	}
	cache.CacheSearch(fees, []string{"maintenance_fee", "park"}, "maintenance_fee", pid...)
	return fees, nil
}

func (_MaintenanceFeeService) CreateMaintenanceFeeRecord(fee model.MaintenanceFee) error {
	fee.Id = uuid.New().String()
	fee.Enabled = true
	_, err := global.DBConn.Insert(fee)
	if err != nil {
		return err
	}
	cache.AbolishRelation("maintenance_fee")
	return nil
}

func (_MaintenanceFeeService) ModifyMaintenanceFee(fee model.MaintenanceFee) error {
	rows, err := global.DBConn.Table(&model.MaintenanceFee{}).NoAutoCondition().ID(fee.Id).Cols("fee", "memo").Update(fee)
	if err != nil {
		if rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation("maintenance_fee")
	cache.AbolishRelation(fmt.Sprintf("maintenance_fee_%s", fee.Id))
	return nil
}

func (_MaintenanceFeeService) ChangeMaintenanceFeeState(fid string, state bool) error {
	rows, err := global.DBConn.Table(&model.MaintenanceFee{}).ID(fid).Update(map[string]interface{}{"enabled": state})
	if err != nil {
		if rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation("maintenance_fee")
	cache.AbolishRelation(fmt.Sprintf("maintenance_fee_%s", fid))
	return nil
}

func (_MaintenanceFeeService) DeleteMaintenanceFee(fid string) error {
	rows, err := global.DBConn.ID(fid).NoAutoCondition().Delete(new(model.MaintenanceFee))
	if err != nil {
		if rows == 0 {
			return exceptions.NewNotFoundError("未能找到匹配的维护费记录。")
		} else {
			return err
		}
	}
	cache.AbolishRelation("maintenance_fee")
	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
	}
	var fee = make([]model.MaintenanceFee, 0)
	err := global.DBConn.
		ID(mid).Limit(1).Find(&fee)
	if err != nil {
		return false, err
	}
	if len(fee) == 0 {
		return false, exceptions.NewNotFoundError("指定维护费条目未找到。")
	}
	var park = make([]model.Park, 0)
	err = global.DBConn.
		ID(fee[0].ParkId).Limit(1).Find(&park)
	if err != nil {
		return false, err
	}
	if len(park) == 0 {
		return false, exceptions.NewNotFoundError("指定维护费所属园区未找到。")
	}
	if park[0].UserId == uid {
		cache.CacheExists([]string{"maintenance_fee", "park"}, "maintenance_fee", mid, uid)
	}
	return park[0].UserId == uid, nil
}