package Adl200Impl

import (
	"fmt"
	"tgk-touch/internal/global"
	"tgk-touch/internal/library/ADL200"
	"time"
)

// ===== 时间读取 =====

// ReadYear 读取电表年份
func (a *Adl200Impl) ReadYear(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0012.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 高字节=年 (如 0x07 表示 2007)
	year := int(byte(value >> 8))
	return year, nil
}

// ReadMonth 读取电表月份
func (a *Adl200Impl) ReadMonth(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0012.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 低字节=月
	month := int(byte(value))
	return month, nil
}

// ReadDay 读取电表日期
func (a *Adl200Impl) ReadDay(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0013.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 低字节=日
	day := int(byte(value))
	return day, nil
}

// ReadHour 读取电表小时
func (a *Adl200Impl) ReadHour(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0013.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 高字节=时
	hour := int(byte(value >> 8))
	return hour, nil
}

// ReadMinute 读取电表分钟
func (a *Adl200Impl) ReadMinute(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0014.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 低字节=分
	minute := int(byte(value))
	return minute, nil
}

// ReadSecond 读取电表秒数
func (a *Adl200Impl) ReadSecond(commUid string, addr byte) (int, error) {
	read, err := ADL200.H0014.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 高字节=秒
	second := int(byte(value >> 8))
	return second, nil
}

// ReadTime 读取电表完整时间
func (a *Adl200Impl) ReadTime(commUid string, addr byte) (time.Time, error) {
	// 读取各个时间组件
	year, err := a.ReadYear(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取年份失败: %v", err)
	}

	month, err := a.ReadMonth(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取月份失败: %v", err)
	}

	day, err := a.ReadDay(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取日期失败: %v", err)
	}

	hour, err := a.ReadHour(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取小时失败: %v", err)
	}

	minute, err := a.ReadMinute(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取分钟失败: %v", err)
	}

	second, err := a.ReadSecond(commUid, addr)
	if err != nil {
		return time.Time{}, fmt.Errorf("读取秒数失败: %v", err)
	}

	// 构建时间对象 (年份为 2 位数字，加 2000)
	loc, _ := time.LoadLocation("Local")
	t := time.Date(
		year+2000,
		time.Month(month),
		day,
		hour,
		minute,
		second,
		0,
		loc,
	)
	return t, nil
}

// ===== 电气参数读取 =====

// ReadVoltage 读取电压 (单相电表只有单相电压)
func (a *Adl200Impl) ReadVoltage(commUid string, addr byte) (totalVoltage, aVoltage, bVoltage, cVoltage float64, err error) {
	read, err := ADL200.H000B.Read(commUid, addr)
	if err != nil {
		return
	}
	// 单位: 0.1V
	aVoltage = float64(read[0]) * 0.1
	// ADL200 是单相电表，总电压即为 A 相电压
	totalVoltage = aVoltage
	return totalVoltage, aVoltage, bVoltage, cVoltage, err
}

// ReadElectricCurrent 读取电流 (单相电表只有单相电流)
func (a *Adl200Impl) ReadElectricCurrent(commUid string, addr byte) (totalElectricCurrent, aElectricCurrent, bElectricCurrent, cElectricCurrent float64, err error) {
	read, err := ADL200.H000C.Read(commUid, addr)
	if err != nil {
		return
	}
	// 单位: 0.01A
	aElectricCurrent = float64(read[0]) * 0.01
	totalElectricCurrent = aElectricCurrent
	return totalElectricCurrent, aElectricCurrent, bElectricCurrent, cElectricCurrent, err
}

// ReadPower 读取功率 (单相电表只有总有功功率)
func (a *Adl200Impl) ReadPower(commUid string, addr byte) (totalPower, aPower, bPower, cPower float64, err error) {
	read, err := ADL200.H000D.Read(commUid, addr)
	if err != nil {
		return
	}
	// 单位: 0.001kW
	totalPower = float64(read[0]) * 0.001
	aPower = totalPower
	return totalPower, aPower, bPower, cPower, err
}

// ReadTotalPower 读取总有功功率
func (a *Adl200Impl) ReadTotalPower(commUid string, addr byte) (totalPower float64, err error) {
	read, err := ADL200.H000D.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	// 单位: 0.001kW
	totalPower = float64(read[0]) * 0.001
	return totalPower, err
}

// ReadEnergy 读取电能 (4 字节数据，需要两个寄存器)
func (a *Adl200Impl) ReadEnergy(commUid string, addr byte) (totalEnergy, aEnergy, bEnergy, cEnergy float64, err error) {
	read, err := ADL200.H0068.Read(commUid, addr)
	if err != nil {
		return
	}
	// 高16位在前，低16位在后 (大端序)
	high := uint32(read[0])     // 高16位
	low := uint32(read[1])      // 低16位
	value := (high << 16) | low // 组合为32位整数
	// 单位: 0.01kWh
	totalEnergy = float64(value) * 0.01
	aEnergy = totalEnergy // 单相电表，A相电能即为总电能
	return totalEnergy, aEnergy, bEnergy, cEnergy, err
}

// ReadPowerFactor 读取功率因数 (单相电表)
func (a *Adl200Impl) ReadPowerFactor(commUid string, addr byte) (totalPf, aPf, bPf, cPf float64, err error) {
	read, err := ADL200.H0010.Read(commUid, addr)
	if err != nil {
		return
	}
	// 单位: 0.001
	aPf = float64(read[0]) * 0.001
	totalPf = aPf
	return totalPf, aPf, bPf, cPf, err
}

// ===== 其他读取 =====

// ReadMsgAddr 读取通信地址
func (a *Adl200Impl) ReadMsgAddr(commUid string, addr byte) (msgAddr byte, err error) {
	read, err := ADL200.H0015.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	value := read[0]
	// 高8位=通信地址 (0~254)
	msgAddr = byte(value >> 8)
	g.Log().Infof("ADL200 ReadMsgAddr raw: 0x%X, msgAddr: 0x%X (%d)", value, msgAddr, msgAddr)
	return msgAddr, nil
}

// ReadMainAddr 读取主控地址 (DL/T645 表号，暂不支持)
func (a *Adl200Impl) ReadMainAddr(commUid string, addr byte) (byte, error) {
	// ADL200 使用表号代替主控地址，此处返回通信地址作为占位
	return a.ReadMsgAddr(commUid, addr)
}

// ReadDailyFreezingTime 读取日冻结时间 (ADL200 不支持日冻结，返回默认)
func (a *Adl200Impl) ReadDailyFreezingTime(commUid string, addr byte) (dailyFreezingTime string, err error) {
	// ADL200 单相电表不支持日冻结时间设置
	return "00:00", nil
}

// ReadMonthlyFreezingTime 读取月冻结时间 (ADL200 不支持月冻结，返回默认)
func (a *Adl200Impl) ReadMonthlyFreezingTime(commUid string, addr byte) (day, hour string, err error) {
	// ADL200 单相电表不支持月冻结时间设置
	return "01", "00", nil
}

// ===== 额外的数据读取方法 =====

// ReadFrequency 读取电网频率
func (a *Adl200Impl) ReadFrequency(commUid string, addr byte) (frequency float64, err error) {
	read, err := ADL200.H0011.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	// 单位: 0.01Hz
	frequency = float64(read[0]) * 0.01
	return frequency, nil
}

// ReadReactivePower 读取无功功率
func (a *Adl200Impl) ReadReactivePower(commUid string, addr byte) (reactivePower float64, err error) {
	read, err := ADL200.H000E.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	// 单位: 0.001kvar
	reactivePower = float64(read[0]) * 0.001
	return reactivePower, nil
}

// ReadApparentPower 读取视在功率
func (a *Adl200Impl) ReadApparentPower(commUid string, addr byte) (apparentPower float64, err error) {
	read, err := ADL200.H000F.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	// 单位: 0.001kVA
	apparentPower = float64(read[0]) * 0.001
	return apparentPower, nil
}

// ReadCombinedEnergy 读取组合有功总电能
func (a *Adl200Impl) ReadCombinedEnergy(commUid string, addr byte) (energy float64, err error) {
	read, err := ADL200.H0000.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	high := uint32(read[0])
	low := uint32(read[1])
	value := (high << 16) | low
	// 单位: 0.01kWh
	energy = float64(value) * 0.01
	return energy, nil
}

// ReadReactiveEnergy 读取总无功电能
func (a *Adl200Impl) ReadReactiveEnergy(commUid string, addr byte) (energy float64, err error) {
	read, err := ADL200.H00B0.Read(commUid, addr)
	if err != nil {
		return 0, err
	}
	high := uint32(read[0])
	low := uint32(read[1])
	value := (high << 16) | low
	// 单位: 0.01kVarh
	energy = float64(value) * 0.01
	return energy, nil
}