package service

import (
	"context"
	"database/sql"
	"electricity_bill_calc/cache"
	"electricity_bill_calc/config"
	"electricity_bill_calc/excel"
	"electricity_bill_calc/global"
	"electricity_bill_calc/logger"
	"electricity_bill_calc/model"
	"fmt"
	"strconv"

	mapset "github.com/deckarep/golang-set/v2"
	"github.com/samber/lo"
	"github.com/uptrace/bun"
	"go.uber.org/zap"
)

type _Meter04kVService struct {
	l *zap.Logger
}

var Meter04kVService = _Meter04kVService{
	l: logger.Named("Service", "Meter04KV"),
}

func (_Meter04kVService) ListMeterDetail(park, keyword string, page int) ([]model.Meter04KV, int64, error) {
	var (
		condition = make([]string, 0)
		meters    = make([]model.Meter04KV, 0)
	)
	cond := global.DB.NewSelect().Model(&meters).
		Where("park_id = ?", park)
	condition = append(condition, park, strconv.Itoa(page))
	if len(keyword) > 0 {
		keywordCond := "%" + keyword + "%"
		cond = cond.WhereGroup(" and ", func(q *bun.SelectQuery) *bun.SelectQuery {
			return q.Where("address like ?", keywordCond).
				WhereOr("code like ?", keywordCond).
				WhereOr("customer_name like ?", keywordCond).
				WhereOr("contact_name like ?", keywordCond).
				WhereOr("contact_phone like ?", keywordCond)
		})
		condition = append(condition, keyword)
	}
	if cachedTotal, err := cache.RetreiveCount("meter_04kv", condition...); cachedTotal != -1 && err == nil {
		if cachedMeters, _ := cache.RetreiveSearch[[]model.Meter04KV]("meter_04kv", condition...); cachedMeters != nil {
			return *cachedMeters, cachedTotal, nil
		}
	}

	ctx, cancel := global.TimeoutContext()
	defer cancel()
	startItem := (page - 1) * config.ServiceSettings.ItemsPageSize
	total, err := cond.
		Order("seq asc", "code asc").
		Limit(config.ServiceSettings.ItemsPageSize).
		Offset(startItem).
		ScanAndCount(ctx)

	relations := lo.Map(meters, func(m model.Meter04KV, _ int) string {
		return fmt.Sprintf("meter_04kv:%s:%s", m.ParkId, m.Code)
	})
	relations = append(relations, "meter_04kv", "park")

	cache.CacheCount(relations, "meter_04kv", int64(total), condition...)
	cache.CacheSearch(meters, relations, "meter_04kv", condition...)
	return meters, int64(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)
	ctx, cancel := global.TimeoutContext()
	defer cancel()
	err := global.DB.NewSelect().Model(meter).
		Where("code = ?", code).
		Where("park_id = ?", park).
		Scan(ctx)
	if err != nil {
		return nil, err
	}
	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 *bun.Tx, ctx *context.Context, meter model.Meter04KV) error {
	_, err := tx.NewInsert().Model(&meter).Exec(*ctx)
	if err != nil {
		tx.Rollback()
	}
	cache.AbolishRelation("meter_04kv")
	return err
}

func (_Meter04kVService) updateMeter(tx *bun.Tx, ctx *context.Context, meter model.Meter04KV) error {
	_, err := tx.NewUpdate().Model(&meter).
		Where("code = ?", meter.Code).
		Where("park_id = ?", meter.ParkId).
		Column("address", "customer_name", "contact_name", "contact_phone", "ratio", "seq", "public_meter", "enabled").
		Exec(*ctx)
	if err != nil {
		tx.Rollback()
	}
	cache.AbolishRelation(fmt.Sprintf("meter_04kv:%s:%s", meter.ParkId, meter.Code))
	return err
}

func (m _Meter04kVService) CreateSingleMeter(meter model.Meter04KV) error {
	ctx, cancel := global.TimeoutContext()
	defer cancel()
	tx, err := global.DB.BeginTx(ctx, &sql.TxOptions{})
	if err != nil {
		return err
	}

	err = m.insertNewMeter(&tx, &ctx, 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 {
	ctx, cancel := global.TimeoutContext()
	defer cancel()
	tx, err := global.DB.BeginTx(ctx, &sql.TxOptions{})
	if err != nil {
		return err
	}

	err = m.updateMeter(&tx, &ctx, *meter)
	if err != nil {
		return err
	}
	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		return err
	}
	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()

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

	allMeterCodes := make([]string, 0)
	err := global.DB.NewSelect().Model((*model.Meter04KV)(nil)).
		Where("park_id = ?", parkId).
		Column("code").
		Scan(ctx, &allMeterCodes)
	if err != nil {
		return err
	}
	meterCodes := mapset.NewSet(allMeterCodes...)

	tx, err := global.DB.BeginTx(ctx, &sql.TxOptions{})
	if err != nil {
		return err
	}

	var (
		updates = make([]model.Meter04KV, 0)
		inserts = make([]model.Meter04KV, 0)
	)
	for _, meter := range meters {
		if meterCodes.Contains(meter.Code) {
			updates = append(updates, meter)
		} else {
			inserts = append(inserts, meter)
		}
	}
	if len(updates) > 0 {
		_, err = tx.NewUpdate().Model(&updates).
			Column("address", "customer_name", "contact_name", "contact_phone", "ratio", "seq", "public_meter", "enabled").
			Bulk().
			Exec(ctx)
		if err != nil {
			tx.Rollback()
			return err
		}
	}
	if len(inserts) > 0 {
		_, err = tx.NewInsert().Model(&inserts).Exec(ctx)
		if err != nil {
			tx.Rollback()
			return err
		}
	}
	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		return err
	}
	cache.AbolishRelation("meter_04kv")
	return nil
}