package service

import (
	"electricity_bill_calc/cache"
	"electricity_bill_calc/config"
	"electricity_bill_calc/excel"
	"electricity_bill_calc/global"
	"electricity_bill_calc/model"
	"fmt"
	"strconv"

	mapset "github.com/deckarep/golang-set/v2"
	"github.com/samber/lo"
	"xorm.io/builder"
	"xorm.io/xorm"
)

type _Meter04kVService struct{}

var Meter04kVService _Meter04kVService

func (_Meter04kVService) ListMeterDetail(park, keyword string, page int) ([]model.Meter04KV, int64, error) {
	var condition = make([]string, 0)
	cond := builder.NewCond().And(builder.Eq{"park_id": park})
	condition = append(condition, park, strconv.Itoa(page))
	if len(keyword) > 0 {
		cond = cond.And(
			builder.Like{"address", keyword}.
				Or(builder.Like{"customer_name", keyword}).
				Or(builder.Like{"code", keyword}).
				Or(builder.Like{"contact_name", keyword}).
				Or(builder.Like{"contact_phone", keyword}))
		condition = append(condition, keyword)
	}
	var (
		total int64
		err   error
	)
	if cachedTotal, err := cache.RetreiveCount("meter_04kv", condition...); cachedTotal != -1 && err == nil {
		total = cachedTotal
	} else {
		total, err = global.DBConn.Where(cond).NoAutoCondition().Count(new(model.Meter04KV))
		if err != nil {
			return make([]model.Meter04KV, 0), -1, err
		}
		cache.CacheCount([]string{"meter_04kv", "park"}, "meter_04kv", total, condition...)
	}
	var meters = make([]model.Meter04KV, 0)
	startItem := (page - 1) * config.ServiceSettings.ItemsPageSize
	if cachedMeters, _ := cache.RetreiveSearch[[]model.Meter04KV]("meter_04kv", condition...); cachedMeters != nil {
		return *cachedMeters, total, nil
	}
	err = global.DBConn.
		Where(cond).
		Limit(config.ServiceSettings.ItemsPageSize, startItem).
		Asc("seq", "code").
		Find(&meters)
	cache.CacheSearch(meters, []string{"meter_04kv", "park"}, "meter_04kv", condition...)
	return meters, total, err
}

func (_Meter04kVService) Get04kVMeterDetail(park, code string) (*model.Meter04KV, error) {
	if cachedMeter, _ := cache.RetreiveEntity[model.Meter04KV]("meter_04kv", fmt.Sprintf("%s_%s", park, code)); cachedMeter != nil {
		return cachedMeter, nil
	}
	var meter = new(model.Meter04KV)
	has, err := global.DBConn.Where(builder.Eq{"code": code, "park_id": park}).NoAutoCondition().Get(meter)
	if err != nil {
		return nil, err
	}
	if !has {
		return nil, nil
	}
	cache.CacheEntity(meter, []string{fmt.Sprintf("meter_04kv_%s_%s", park, code), "park"}, "meter_04kv", fmt.Sprintf("%s_%s", park, code))
	return meter, nil
}

func (_Meter04kVService) insertNewMeter(tx *xorm.Session, meter model.Meter04KV) error {
	_, err := tx.Insert(meter)
	if err != nil {
		tx.Rollback()
	}
	cache.AbolishRelation("meter_04kv")
	return err
}

func (_Meter04kVService) updateMeter(tx *xorm.Session, meter model.Meter04KV) error {
	_, err := tx.
		Where(builder.Eq{"code": meter.Code, "park_id": meter.ParkId}).
		Cols("address", "customer_name", "contact_name", "contact_phone", "ratio", "seq", "public_meter", "dilute", "enabled").
		NoAutoCondition().
		Update(meter)
	if err != nil {
		tx.Rollback()
	}
	cache.AbolishRelation("meter_04kv")
	cache.AbolishRelation(fmt.Sprintf("meter_04kv_%s_%s", meter.ParkId, meter.Code))
	return err
}

func (m _Meter04kVService) CreateSingleMeter(meter model.Meter04KV) error {
	tx := global.DBConn.NewSession()
	if err := tx.Begin(); err != nil {
		return err
	}
	defer tx.Close()

	err := m.insertNewMeter(tx, meter)
	if err != nil {
		return err
	}
	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		return err
	}
	cache.AbolishRelation("meter_04kv")
	cache.AbolishRelation(fmt.Sprintf("meter_04kv_%s_%s", meter.ParkId, meter.Code))
	return nil
}

func (m _Meter04kVService) UpdateSingleMeter(meter *model.Meter04KV) error {
	tx := global.DBConn.NewSession()
	if err := tx.Begin(); err != nil {
		return err
	}
	defer tx.Close()

	err := m.updateMeter(tx, *meter)
	if err != nil {
		return err
	}
	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		return err
	}
	cache.AbolishRelation("meter_04kv")
	cache.AbolishRelation(fmt.Sprintf("meter_04kv_%s_%s", meter.ParkId, meter.Code))
	return nil
}

func (_Meter04kVService) DuplicateMeterCodeValidate(meters []model.Meter04KV) []excel.ExcelAnalysisError {
	errs := make([]excel.ExcelAnalysisError, 0)
	for i := 0; i < len(meters); i++ {
		for j := i + 1; j < len(meters); j++ {
			if meters[j].Code == meters[i].Code {
				errs = append(errs, excel.ExcelAnalysisError{Row: j + 1, Col: 0, Err: excel.AnalysisError{Err: fmt.Errorf("第 %d 行表计表号与第 %d 行表计表号重复！", j+1, i+1)}})
			}
		}
	}
	return errs
}

func (m _Meter04kVService) BatchCreateMeter(meters []model.Meter04KV) error {
	parkIds := lo.Reduce(meters, func(acc mapset.Set[string], elem model.Meter04KV, index int) mapset.Set[string] {
		acc.Add(elem.ParkId)
		return acc
	}, mapset.NewSet[string]())
	if parkIds.Cardinality() > 1 {
		return fmt.Errorf("一次只能向同一个园区中添加0.4kV表计。")
	}
	parkId, _ := parkIds.Pop()

	allMeterCodes := make([]string, 0)
	err := global.DBConn.Table(&model.Meter04KV{}).Where(builder.Eq{"park_id": parkId}).Select("code").Find(&allMeterCodes)
	if err != nil {
		return err
	}
	meterCodes := mapset.NewSet(allMeterCodes...)

	tx := global.DBConn.NewSession()
	if err := tx.Begin(); err != nil {
		return err
	}
	defer tx.Close()

	for _, meter := range meters {
		var err error
		if meterCodes.Contains(meter.Code) {
			err = m.updateMeter(tx, meter)
		} else {
			err = m.insertNewMeter(tx, meter)
		}
		if err != nil {
			return err
		}
	}
	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		return err
	}
	cache.AbolishRelation("meter_04kv")
	return nil
}