package device

import (
    "testing"
    "time"
    "fmt"
    "reflect"
    "github.com/rs/zerolog"
    "io/ioutil"
)

// monday
var test_time = time.Date(2022, time.October, 24, 0, 0, 0, 0, time.Local)




var test_presets = []Preset{
    {Label: "default", Value: 17, Color: "#012a36"},
    {Label: "normal", Value: 19, Color: "#b6244f"},
}

var test_setpoints = []Setpoint{
    {Start: 7*60, Preset_id: 1},
    {Start: 8*60, Preset_id: 0},
    {Start: 16*60, Preset_id: 1},
    {Start: 22*60, Preset_id: 0},
}

var test_weekprogram = WeekProgram{
    Monday:    test_setpoints,
    Thuesday:  test_setpoints,
    Wednesday: test_setpoints,
    Thursday : test_setpoints,
    Friday:    test_setpoints,
    Saturday:  test_setpoints,
    Sunday:    test_setpoints,
}

var test_programs = Programs{
    "default": test_weekprogram,
}

var test_device = Device {
    Name: "valid",
    Settings: DeviceSettings{
        Programs: test_programs,
        Presets: test_presets,
        TVR: DefaultTVRSettings,
    },
    CurrentSetpoint: 0,
    State: DeviceState{
        Mode: "program",
        Setpoint: 14,
        Time: test_time,
        Program_name: "default",
    },
}


func TestStateTopic(t *testing.T) {
    topic := test_device.StateTopic()
    if topic != "heater/valid/state" {
        t.Errorf("Got %s; want heater/valid/state", topic)
    }
}

func TestProgram(t *testing.T) {
    //case 1: no program set in state return default
    case1_device := test_device
    case1_device.State.Program_name = ""

    //case 2: program set "confort" must return it
    var test_confort_weekprogram = WeekProgram{
        Monday:    test_setpoints,
        Thuesday:  test_setpoints,
        Wednesday: test_setpoints,
        Thursday : test_setpoints,
        Friday:    test_setpoints,
        Saturday:  test_setpoints,
        Sunday:    test_setpoints,
    }
    case2_device := test_device
    case2_device.Settings.Programs = Programs{
        "default": test_weekprogram,
        "confort": test_confort_weekprogram,
    }
    case2_device.State.Program_name = "confort"

    //case 3: program set "confort" but not exist
    case3_device := test_device
    case3_device.State.Program_name = "confort"

    var tests = []struct {
        name string
        device Device
        result WeekProgram
        err    error
    }{
        {"case 1 no program set use default", case1_device, DefaultWeekProgram, nil},
        {"case 2 program confort", case2_device, test_confort_weekprogram, nil},
        {"case 3 program confort no defined", case3_device, WeekProgram{}, Error("device valid don't have confort program")},
    }
    for _, tt := range tests {
        testname := fmt.Sprintf("%s", tt.name )
        t.Run(testname, func(t *testing.T) {
            prog, err := tt.device.Program()
            if err != tt.err {
                t.Errorf("got %s, want %s", err, tt.err)
            }
            if !reflect.DeepEqual(prog,tt.result) {
                t.Errorf("got %v, want %v", prog, tt.result)
            }
        })
    }
}


func TestCheckSetpoint(t *testing.T) {
    timeNow = func() time.Time {
        return test_time
    }

    device1 := test_device
    device1.Name = "1"
    device1.State = DeviceState{
        Mode: "program",
        Setpoint: 0,
        Time: test_time,
        Program_name: "",
    }

    device2 := test_device
    device2.Name = "2"
    device2.State.Program_name = "unknown"

    var tests = []struct{
        device Device
        want []Message
        err error
    }{
        {device1, []Message{Message{
            Payload: []byte("{\"current_heating_setpoint\": 17}"),
            Topic: "zigbee2mqtt/TVR/1/set",
            Retain: false,
        }}, nil} ,
        {device2, []Message{}, Error("device 2 don't have unknown program")},
    }

    for _, tt := range tests {
        testname := fmt.Sprintf("%s", tt.device.Name )
        t.Run(testname, func(t *testing.T) {

             result := []Message{}

            rchan := make(chan Message, 10)
            errchan := make(chan error, 1)

            go func(result chan Message, errchan chan error) {
                logger := zerolog.New(ioutil.Discard).With().Timestamp().Logger()
                errchan <- tt.device.CheckSetpoint(&logger, result)
                close(rchan)
                close(errchan)
            }(rchan, errchan)

            for msg := range rchan {
                result = append(result, msg)
            }

            err, ok := <- errchan
            if !ok {
                t.Fatal(err)
            }

            if err != tt.err {
                t.Errorf("got %s, want %s", err, tt.err)
            }

            if !reflect.DeepEqual(result,tt.want) {
                t.Errorf("got %v, want %v", result, tt.want)
            }
        })
    }
}