package charger

// LICENSE

// Copyright (c) evcc.io (andig, naltatis, premultiply)

// This module is NOT covered by the MIT license. All rights reserved.

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

import (
	"context"
	"encoding/binary"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/evcc-io/evcc/api"
	"github.com/evcc-io/evcc/util"
	"github.com/evcc-io/evcc/util/modbus"
	"github.com/volkszaehler/mbmd/meters/rs485"
)

// smartEVSE is an api.Charger implementation
type smartEVSE struct {
	log  *util.Logger
	conn *modbus.Connection
	curr uint16
}

const (
	smartEVSERegSerial             = 0x0000 // 5 regs
	smartEVSERegFirmware           = 0x0005
	smartEVSERegExternalLock       = 0x0010
	smartEVSERegI2Cerrors          = 0x0011
	smartEVSERegLockLock           = 0x0015
	smartEVSERegUnlockLock         = 0x0016
	smartEVSERegDisconnectCP       = 0x0017
	smartEVSERegMaxCurrentAdv      = 0x0102
	smartEVSERegChargingState      = 0x0103
	smartEVSERegTemp               = 0x0104 // 1 °C uint16
	smartEVSERegCurrents           = 0x0105 // 1/256 A * 3 uint16
	smartEVSERegSessionEnergy      = 0x0108 // 1/256 kWh uint16
	smartEVSERegVoltages           = 0x0109 // 1/256 V * 3 uint16
	smartEVSERegEnergy             = 0x010d // 1/256 kWh uint32s
	smartEVSERegMaxCurrent         = 0x0201 // Lbyte max current 1 A, Hbyte 1s max current 1 A
	smartEVSERegSettings           = 0x0204 // bits: 7: x, 6: x, 5: x, 4: CP_AUTO_DISCONNECT, 3: MISUSE_LOCKPORT_AS_CP_DISCONNECT, 2: DCL_MUST_BE_PRESENT, 1: LOCK_STATE, 0: PHASES
	smartEVSERegCPDisconnectTime   = 0x0208 // CP interruption time 1 ms uint16
	smartEVSERegTimeoutBeforeCPDis = 0x0209 // time the board waits before it disconnects CP 1 ms uint16

	smartEVSEConfAutoCPDisconnect             = 0x10
	smartEVSEConfMisuseLockPortAsCPDisconnect = 0x8
	smartEVSEConfDCLMustBePresent             = 0x4
	smartEVSEConfLockState                    = 0x2
	smartEVSEConfPhases                       = 0x1
)

func init() {
	registry.AddCtx("smartevse", NewsmartEVSEFromConfig)
}

// NewsmartEVSEFromConfig creates a new smartEVSE ModbusTCP charger
func NewsmartEVSEFromConfig(ctx context.Context, other map[string]any) (api.Charger, error) {
	cc := modbus.Settings{
		ID: 1,
	}

	if err := util.DecodeOther(other, &cc); err != nil {
		return nil, err
	}

	return NewsmartEVSE(ctx, cc.URI, cc.Device, cc.Comset, cc.Baudrate, cc.Protocol(), cc.ID)
}

// NewsmartEVSE creates a new charger
func NewsmartEVSE(ctx context.Context, uri, device, comset string, baudrate int, proto modbus.Protocol, slaveID uint8) (*smartEVSE, error) {
	conn, err := modbus.NewConnection(ctx, uri, device, comset, baudrate, proto, slaveID)
	if err != nil {
		return nil, err
	}

	log := util.NewLogger("smartevse")
	conn.Logger(log.TRACE)

	wb := &smartEVSE{
		log:  log,
		conn: conn,
		curr: 6,
	}

	return wb, err
}

// Status implements the api.Charger interface
func (wb *smartEVSE) Status() (api.ChargeStatus, error) {
	b, err := wb.conn.ReadInputRegisters(smartEVSERegChargingState, 1)
	if err != nil {
		return api.StatusNone, err
	}

	status := binary.BigEndian.Uint16(b) & 0xff

	switch status {
	case 0:
		return api.StatusNone, nil
	case 1:
		return api.StatusA, nil
	case 2:
		return api.StatusB, nil
	case 3:
		return api.StatusC, nil
	default:
		return api.StatusNone, fmt.Errorf("invalid status: %d", status)
	}
}

// Enabled implements the api.Charger interface
func (wb *smartEVSE) Enabled() (bool, error) {
	b, err := wb.conn.ReadInputRegisters(smartEVSERegMaxCurrentAdv, 1)
	if err != nil {
		return false, err
	}

	return (binary.BigEndian.Uint16(b) >> 8) != 0, nil
}

// Enable implements the api.Charger interface
func (wb *smartEVSE) Enable(enable bool) error {
	var u uint16
	if enable {
		u = ((wb.curr << 8) | wb.curr)
	}

	_, err := wb.conn.WriteSingleRegister(smartEVSERegMaxCurrent, u)

	return err
}

// MaxCurrent implements the api.Charger interface
func (wb *smartEVSE) MaxCurrent(current int64) error {
	curr := uint16(current)

	_, err := wb.conn.WriteSingleRegister(smartEVSERegMaxCurrent, ((curr << 8) | curr))
	if err == nil {
		wb.curr = curr
	}

	return err
}

var _ api.Meter = (*smartEVSE)(nil)

// CurrentPower implements the api.Meter interface
func (wb *smartEVSE) CurrentPower() (float64, error) {
	v1, v2, v3, err := wb.Voltages()
	if err != nil {
		return 0, err
	}
	i1, i2, i3, err := wb.Currents()
	if err != nil {
		return 0, err
	}

	return v1*i1 + v2*i2 + v3*i3, nil
}

var _ api.MeterEnergy = (*smartEVSE)(nil)

// TotalEnergy implements the api.MeterEnergy interface
func (wb *smartEVSE) TotalEnergy() (float64, error) {
	b, err := wb.conn.ReadInputRegisters(smartEVSERegEnergy, 2)
	if err != nil {
		return 0, err
	}

	return rs485.RTUUint32ToFloat64Swapped(b) / 256, err
}

var _ api.ChargeRater = (*smartEVSE)(nil)

// ChargedEnergy implements the api.ChargeRater interface
func (wb *smartEVSE) ChargedEnergy() (float64, error) {
	b, err := wb.conn.ReadInputRegisters(smartEVSERegSessionEnergy, 1)
	if err != nil {
		return 0, err
	}

	return float64(binary.BigEndian.Uint16(b)) / 256, err
}

// getPhaseValues returns 3 sequential register values
func (wb *smartEVSE) getPhaseValues(reg uint16, divider float64) (float64, float64, float64, error) {
	b, err := wb.conn.ReadInputRegisters(reg, 3)
	if err != nil {
		return 0, 0, 0, err
	}

	var res [3]float64
	for i := range res {
		res[i] = float64(binary.BigEndian.Uint16(b[2*i:])) / divider
	}

	return res[0], res[1], res[2], nil
}

var _ api.PhaseCurrents = (*smartEVSE)(nil)

// Currents implements the api.PhaseCurrents interface
func (wb *smartEVSE) Currents() (float64, float64, float64, error) {
	return wb.getPhaseValues(smartEVSERegCurrents, 256)
}

var _ api.PhaseVoltages = (*smartEVSE)(nil)

// Voltages implements the api.PhaseVoltages interface
func (wb *smartEVSE) Voltages() (float64, float64, float64, error) {
	return wb.getPhaseValues(smartEVSERegVoltages, 256)
}

var _ api.PhaseSwitcher = (*smartEVSE)(nil)

// Phases1p3p implements the api.PhaseSwitcher interface
func (wb *smartEVSE) Phases1p3p(phases int) error {
	b, err := wb.conn.ReadHoldingRegisters(smartEVSERegSettings, 1)
	if err != nil {
		return err
	}

	settings := binary.BigEndian.Uint16(b) &^ smartEVSEConfPhases // clear bit 0

	if phases == 3 {
		settings |= 1 // set bit 0 (smartEVSEConfPhases)
	}

	return whenDisabled(wb, func() error {
		// Wait 10 seconds before switching phases
		// can this option be made configurable in evcc.yaml?
		time.Sleep(10 * time.Second)

		// Switch phases
		_, err := wb.conn.WriteSingleRegister(smartEVSERegSettings, settings)
		if err != nil {
			// Wait 10 seconds after switching phases
			time.Sleep(10 * time.Second)
		}

		return err
	})
}

var _ api.Diagnosis = (*smartEVSE)(nil)

// Diagnose implements the api.Diagnosis interface
func (wb *smartEVSE) Diagnose() {
	if b, err := wb.conn.ReadInputRegisters(smartEVSERegSerial, 5); err == nil {
		fmt.Printf("\tSerial: %s\n", strings.TrimLeft(strconv.Itoa(int(binary.BigEndian.Uint32(b))), "0"))
	}
	if b, err := wb.conn.ReadInputRegisters(smartEVSERegFirmware, 1); err == nil {
		fmt.Printf("\tFirmware: %d.%d.%d\n", b[0]>>4, b[0]&0x0f, b[1])
	}

	if b, err := wb.conn.ReadInputRegisters(smartEVSERegTemp, 1); err == nil {
		fmt.Printf("\tBoard Temp: %d°C\n", binary.BigEndian.Uint16(b))
	}

	if b, err := wb.conn.ReadInputRegisters(smartEVSERegTemp, 1); err == nil {
		opt := binary.BigEndian.Uint16(b)
		fmt.Printf("\tOptions: 32/16A: %d DCL: %d\n", opt&0x2, opt&0x1)
	}

	if b, err := wb.conn.ReadHoldingRegisters(smartEVSERegSettings, 1); err == nil {
		settings := binary.BigEndian.Uint16(b)
		phasenum := 1
		if settings&smartEVSEConfPhases == 1 {
			phasenum = 3
		}
		fmt.Printf("\tSettings:\n\t\tPhases: %d\n\t\tLockState: %t\n\t\tDCLMustbePresent: %t\n\t\tLockPortDrivingCPRelais: %t\n\t\tCPInterruptAuto: %t\n", phasenum, settings&0x2 != 0, settings&0x4 != 0, settings&0x8 != 0, settings&0x10 != 0)
	}

	if b, err := wb.conn.ReadHoldingRegisters(smartEVSERegTimeoutBeforeCPDis, 1); err == nil {
		timeoutms := binary.BigEndian.Uint16(b)
		fmt.Printf("\tTimeout before starting CP interruption: %dms\n", timeoutms)
	}

	if b, err := wb.conn.ReadHoldingRegisters(smartEVSERegCPDisconnectTime, 1); err == nil {
		cptime := binary.BigEndian.Uint16(b)
		fmt.Printf("\tCP interruption time: %dms\n", cptime)
	}
}