package calculate

import (
	"electricity_bill_calc/model"
	"electricity_bill_calc/model/calculate"
	"electricity_bill_calc/repository"
	"github.com/shopspring/decimal"
	"time"
	"unsafe"
)

// 核算园区中的全部公摊表计的电量用量
func PooledMetersCalculate(report *model.ReportIndex, periodStart time.Time,
	periodEnd time.Time, meterDetails []*model.MeterDetail,
	summary calculate.Summary) ([]calculate.Meter, error) {
	poolingMeterReadings, err := repository.CalculateRepository.GetMeterReadings(report.Id, model.METER_INSTALLATION_POOLING)
	if err != nil {
		return nil, err
	}

	lastTermPoolingMeterReadings, err := repository.CalculateRepository.GetLastPeriodReadings(report.Id, model.METER_INSTALLATION_POOLING)
	if err != nil {
		return nil, err
	}

	poolingMeterReadings = append(poolingMeterReadings, lastTermPoolingMeterReadings...)
	if len(poolingMeterReadings) <= 0 {
		return nil, nil
	}

	var poolingMetersReports []calculate.Meter
	for _, meter := range meterDetails {
		poolingMetersReport, err := determinePublicMeterConsumptions(meter.Code, periodStart, periodEnd, poolingMeterReadings, *meter, summary)
		if err != nil {
			return nil, err
		}
		poolingMetersReports = append(poolingMetersReports, poolingMetersReport)
	}
	return poolingMetersReports, nil
}

// 确定指定非商户表计在指定时间段内的全部电量
func determinePublicMeterConsumptions(meterId string, periodStart time.Time,
	periodEnd time.Time, readings []model.MeterReading,
	meterDetail model.MeterDetail, summary calculate.Summary) (calculate.Meter, error) {
	startReading, err := DeterminePublicMeterStartReading(meterId, periodStart, meterDetail.DetachedAt.Time, readings)
	if err != nil {
		return calculate.Meter{}, err
	}

	endReading, err := DeterminePublicMeterEndReading(meterId, periodEnd, meterDetail.DetachedAt.Time, readings)
	if err != nil {
		return calculate.Meter{}, err
	}

	overall, err := ComputeOverall(*startReading, *endReading, summary)
	if err != nil {
		return calculate.Meter{}, err
	}

	critical, err := ComputeCritical(*startReading, *endReading, summary)
	if err != nil {
		return calculate.Meter{}, err
	}

	peak, err := ComputePeak(*startReading, *endReading, summary)
	if err != nil {
		return calculate.Meter{}, err
	}

	flat, err := ComputeFlat(*startReading, *endReading, summary)
	if err != nil {
		return calculate.Meter{}, err
	}

	valley, err := ComputeValley(*startReading, *endReading, summary)
	if err != nil {
		return calculate.Meter{}, err
	}

	return calculate.Meter{
		Code:        meterId,
		Detail:      meterDetail,
		CoveredArea: meterDetail.Area.Decimal,
		LastTermReading: (*calculate.Reading)(unsafe.Pointer(&model.Reading{
			Ratio:    startReading.Ratio,
			Overall:  startReading.Overall,
			Critical: startReading.Critical,
			Peak:     startReading.Peak,
			Flat:     startReading.Flat,
			Valley:   startReading.Valley,
		})),
		CurrentTermReading: (*calculate.Reading)(unsafe.Pointer(&model.Reading{
			Ratio:    endReading.Ratio,
			Overall:  endReading.Overall,
			Critical: endReading.Critical,
			Peak:     endReading.Peak,
			Flat:     endReading.Flat,
			Valley:   endReading.Valley,
		})),
		Overall:                 overall,
		Critical:                critical,
		Peak:                    peak,
		Flat:                    flat,
		Valley:                  valley,
		AdjustLoss:              model.ConsumptionUnit{},
		PooledBasic:             model.ConsumptionUnit{},
		PooledAdjust:            model.ConsumptionUnit{},
		PooledLoss:              model.ConsumptionUnit{},
		PooledPublic:            model.ConsumptionUnit{},
		SharedPoolingProportion: decimal.Decimal{},
		Poolings:                nil,
	}, nil
}