package service

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

	"github.com/samber/lo"
	"github.com/shopspring/decimal"
	"xorm.io/builder"
	"xorm.io/xorm"
	"xorm.io/xorm/schemas"
)

type _EndUserService struct{}

type MeterAppears struct {
	Meter   string
	Appears int64
}

var EndUserService _EndUserService

func (_EndUserService) SearchEndUserRecord(reportId, keyword string, page int) ([]model.EndUserDetail, int64, error) {
	var conditions = make([]string, 0)
	conditions = append(conditions, reportId, strconv.Itoa(page))
	cond := builder.NewCond().And(builder.Eq{"report_id": reportId})
	if len(keyword) > 0 {
		cond = cond.And(
			builder.Like{"customer_name", keyword}.
				Or(builder.Like{"contact_name", keyword}).
				Or(builder.Like{"contact_phone", keyword}).
				Or(builder.Like{"meter_04kv_id", keyword}),
		)
		conditions = append(conditions, keyword)
	}
	var (
		total int64
		err   error
	)
	if cachedTotal, err := cache.RetreiveCount("end_user_detail", conditions...); cachedTotal != -1 && err == nil {
		total = cachedTotal
	} else {
		total, err = global.DBConn.
			Table(&model.EndUserDetail{}).
			Where(cond).
			Count()
		if err != nil {
			return make([]model.EndUserDetail, 0), -1, err
		}
		cache.CacheCount([]string{"end_user", "report", "park"}, "end_user_detail", total, conditions...)
	}
	startItem := (page - 1) * config.ServiceSettings.ItemsPageSize
	if cachedEndUsers, _ := cache.RetreiveSearch[[]model.EndUserDetail]("end_user_detail", conditions...); cachedEndUsers != nil {
		return *cachedEndUsers, total, nil
	}
	endUsers := make([]model.EndUserDetail, 0)
	err = global.DBConn.
		Where(cond).
		Limit(config.ServiceSettings.ItemsPageSize, startItem).
		Asc("seq").
		Find(&endUsers)
	cache.CacheSearch(endUsers, []string{"end_user_detail", "report", "park"}, "end_user_detail", conditions...)
	return endUsers, total, err
}

func (_EndUserService) AllEndUserRecord(reportId string) ([]model.EndUserDetail, error) {
	if cachedEndUsers, _ := cache.RetreiveSearch[[]model.EndUserDetail]("end_user_detail", "report", reportId); cachedEndUsers != nil {
		return *cachedEndUsers, nil
	}
	users := make([]model.EndUserDetail, 0)
	err := global.DBConn.
		Where(builder.Eq{"report_id": reportId}).
		Asc("seq", "meter_04kv_id").
		Find(&users)
	cache.CacheSearch(users, []string{"end_user_detail", "report", "park"}, "end_user_detail", "report", reportId)
	return users, err
}

func (_EndUserService) FetchSpecificEndUserRecord(reportId, parkId, meterId string) (*model.EndUserDetail, error) {
	if cachedEndUser, _ := cache.RetreiveEntity[model.EndUserDetail]("end_user_detail", fmt.Sprintf("%s_%s_%s", reportId, parkId, meterId)); cachedEndUser != nil {
		return cachedEndUser, nil
	}
	record := new(model.EndUserDetail)
	_, err := global.DBConn.
		ID(schemas.NewPK(reportId, parkId, meterId)).
		NoAutoCondition().
		Get(record)
	cache.CacheEntity(record, []string{"end_user_detail", "report", "park"}, "end_user_detail", fmt.Sprintf("%s_%s_%s", reportId, parkId, meterId))
	return record, err
}

func (_EndUserService) UpdateEndUserRegisterRecord(tx *xorm.Session, record model.EndUserDetail) (err error) {
	record.CalculatePeriod()
	if record.Initialize {
		_, err = tx.ID(schemas.NewPK(record.ReportId, record.ParkId, record.MeterId)).
			Cols(
				"last_period_overall",
				"current_period_overall",
				"adjust_overall",
				"last_period_critical",
				"last_period_peak",
				"last_period_flat",
				"last_period_valley",
				"current_period_critical",
				"current_period_peak",
				"current_period_flat",
				"current_period_valley",
				"adjust_critical",
				"adjust_peak",
				"adjust_flat",
				"adjust_valley",
				"overall",
				"critical",
				"peak",
				"flat",
				"valley",
			).
			Update(record)
	} else {
		_, err = tx.ID(schemas.NewPK(record.ReportId, record.ParkId, record.MeterId)).
			Cols(
				"current_period_overall",
				"adjust_overall",
				"current_period_critical",
				"current_period_peak",
				"current_period_flat",
				"current_perios_valley",
				"adjust_critical",
				"adjust_peak",
				"adjust_flat",
				"adjust_valley",
				"overall",
				"critical",
				"peak",
				"flat",
				"valley",
			).
			Update(record)
	}
	cache.AbolishRelation("end_user_detail")
	return
}

func (_EndUserService) newVirtualExcelAnalysisError(err error) *excel.ExcelAnalysisError {
	return &excel.ExcelAnalysisError{Col: -1, Row: -1, Err: excel.AnalysisError{Err: err}}
}

func (es _EndUserService) BatchImportNonPVRegister(reportId string, file io.Reader) *exceptions.BatchError {
	errs := exceptions.NewBatchError()
	users, err := es.AllEndUserRecord(reportId)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	reportDetail := new(model.Report)
	has, err := global.DBConn.ID(reportId).NoAutoCondition().Get(reportDetail)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	if !has {
		errs.AddError(es.newVirtualExcelAnalysisError(errors.New("未能找到相应的报表。")))
		return errs
	}
	meterAppers := make([]MeterAppears, 0)
	err = global.DBConn.Table(new(model.EndUserDetail)).Where(builder.Eq{"park_id": reportDetail.ParkId}).Select("meter_04kv_id as meter, count(*) as appears").GroupBy("meter_04kv_id").Find(&meterAppers)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	indexedUsers := lo.Reduce(
		users,
		func(acc map[string]model.EndUserDetail, elem model.EndUserDetail, index int) map[string]model.EndUserDetail {
			acc[elem.MeterId] = elem
			return acc
		},
		make(map[string]model.EndUserDetail, 0),
	)
	analyzer, err := excel.NewEndUserNonPVExcelAnalyzer(file)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	imports, excelErrs := analyzer.Analysis(*new(model.EndUserImport))
	if len(excelErrs) > 0 {
		for _, e := range excelErrs {
			errs.AddError(e)
		}
		return errs
	}
	tx := global.DBConn.NewSession()
	if err = tx.Begin(); err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	defer tx.Close()

	for _, im := range imports {
		if elem, ok := indexedUsers[im.MeterId]; ok {
			if appears, has := lo.Find(meterAppers, func(m MeterAppears) bool {
				return m.Meter == elem.MeterId
			}); has {
				if appears.Appears <= 1 {
					elem.LastPeriodOverall = im.LastPeriodOverall
					elem.LastPeriodCritical = decimal.Zero
					elem.LastPeriodPeak = decimal.Zero
					elem.LastPeriodValley = decimal.Zero
					elem.LastPeriodFlat = elem.LastPeriodOverall.Sub(elem.LastPeriodCritical).Sub(elem.LastPeriodPeak).Sub(elem.LastPeriodValley)
					elem.Initialize = true
				}
			}
			elem.CurrentPeriodOverall = im.CurrentPeriodOverall
			elem.AdjustOverall = im.AdjustOverall
			elem.CurrentPeriodCritical = decimal.Zero
			elem.CurrentPeriodPeak = decimal.Zero
			elem.CurrentPeriodValley = decimal.Zero
			elem.CurrentPeriodFlat = elem.CurrentPeriodOverall.Sub(elem.CurrentPeriodCritical).Sub(elem.CurrentPeriodPeak).Sub(elem.CurrentPeriodValley)
			elem.AdjustCritical = decimal.Zero
			elem.AdjustPeak = decimal.Zero
			elem.AdjustValley = decimal.Zero
			elem.AdjustFlat = elem.AdjustOverall.Sub(elem.AdjustCritical).Sub(elem.AdjustPeak).Sub(elem.AdjustValley)
			err := es.UpdateEndUserRegisterRecord(tx, elem)
			if err != nil {
				errs.AddError(es.newVirtualExcelAnalysisError(err))
			}
		} else {
			errs.AddError(exceptions.NewNotFoundError(fmt.Sprintf("表计 %s 未找到", im.MeterId)))
		}
	}
	if errs.Len() > 0 {
		tx.Rollback()
		return errs
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		errs.AddError(es.newVirtualExcelAnalysisError(err))
	}
	cache.AbolishRelation("end_user_detail")
	return errs
}

func (es _EndUserService) BatchImportPVRegister(reportId string, file io.Reader) *exceptions.BatchError {
	errs := exceptions.NewBatchError()
	users, err := es.AllEndUserRecord(reportId)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	reportDetail := new(model.Report)
	has, err := global.DBConn.ID(reportId).NoAutoCondition().Get(reportDetail)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	if !has {
		errs.AddError(es.newVirtualExcelAnalysisError(errors.New("未能找到相应的报表。")))
		return errs
	}
	meterAppers := make([]MeterAppears, 0)
	err = global.DBConn.Table(new(model.EndUserDetail)).Where(builder.Eq{"park_id": reportDetail.ParkId}).Select("meter_04kv_id as meter, count(*) as appears").GroupBy("meter_04kv_id").Find(&meterAppers)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	indexedUsers := lo.Reduce(
		users,
		func(acc map[string]model.EndUserDetail, elem model.EndUserDetail, index int) map[string]model.EndUserDetail {
			acc[elem.MeterId] = elem
			return acc
		},
		make(map[string]model.EndUserDetail, 0),
	)
	analyzer, err := excel.NewEndUserPVExcelAnalyzer(file)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	imports, excelErrs := analyzer.Analysis(*new(model.EndUserImport))
	if len(excelErrs) > 0 {
		for _, e := range excelErrs {
			errs.AddError(e)
		}
		return errs
	}

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

	for _, im := range imports {
		if elem, ok := indexedUsers[im.MeterId]; ok {
			if appears, has := lo.Find(meterAppers, func(m MeterAppears) bool {
				return m.Meter == elem.MeterId
			}); has {
				if appears.Appears <= 1 {
					elem.LastPeriodOverall = im.LastPeriodOverall
					elem.LastPeriodCritical = im.LastPeriodCritical.Decimal
					elem.LastPeriodPeak = im.LastPeriodPeak.Decimal
					elem.LastPeriodValley = im.LastPeriodValley.Decimal
					elem.LastPeriodFlat = elem.LastPeriodOverall.Sub(elem.LastPeriodCritical).Sub(elem.LastPeriodPeak).Sub(elem.LastPeriodValley)
					elem.Initialize = true
				}
			}
			elem.CurrentPeriodOverall = im.CurrentPeriodOverall
			elem.AdjustOverall = im.AdjustOverall
			elem.CurrentPeriodCritical = im.CurrentPeriodCritical.Decimal
			elem.CurrentPeriodPeak = im.CurrentPeriodPeak.Decimal
			elem.CurrentPeriodValley = im.CurrentPeriodValley.Decimal
			elem.CurrentPeriodFlat = elem.CurrentPeriodOverall.Sub(elem.CurrentPeriodCritical).Sub(elem.CurrentPeriodPeak).Sub(elem.CurrentPeriodValley)
			elem.AdjustCritical = im.AdjustCritical.Decimal
			elem.AdjustPeak = im.AdjustPeak.Decimal
			elem.AdjustValley = im.AdjustValley.Decimal
			elem.AdjustFlat = elem.AdjustOverall.Sub(elem.AdjustCritical).Sub(elem.AdjustPeak).Sub(elem.AdjustValley)
			err := es.UpdateEndUserRegisterRecord(tx, elem)
			if err != nil {
				errs.AddError(es.newVirtualExcelAnalysisError(err))
			}
		} else {
			errs.AddError(es.newVirtualExcelAnalysisError(exceptions.NewNotFoundError(fmt.Sprintf("表计 %s 未找到", im.MeterId))))
		}
	}
	if errs.Len() > 0 {
		tx.Rollback()
		return errs
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		errs.AddError(es.newVirtualExcelAnalysisError(err))
	}
	cache.AbolishRelation("end_user_detail")
	return errs
}