// Package miot provides white-box tests for miot_client_api.go cloud API calls.
package miot

import (
	"testing"
)

// ============================================================================
// SetProp — no HTTP client
// ============================================================================

func TestSetProp_NoHTTP(t *testing.T) {
	c := NewMIoTClient("test", nil, "uid", "cn", CtrlModeCloud)
	defer c.Stop()

	err := c.SetProp("did1", 2, 1, "value")
	if err == nil {
		t.Error("SetProp without HTTP client should error")
	}
}

// ============================================================================
// GetProp — no HTTP client
// ============================================================================

func TestGetProp_NoHTTP(t *testing.T) {
	c := NewMIoTClient("test", nil, "uid", "cn", CtrlModeCloud)
	defer c.Stop()

	val, err := c.GetProp("did1", 2, 1)
	if err == nil {
		t.Error("GetProp without HTTP client should error")
	}
	if val != nil {
		t.Errorf("GetProp should return nil value on error, got %v", val)
	}
}

// ============================================================================
// Action — no HTTP client
// ============================================================================

func TestAction_NoHTTP(t *testing.T) {
	c := NewMIoTClient("test", nil, "uid", "cn", CtrlModeCloud)
	defer c.Stop()

	result, err := c.Action("did1", 2, 1, []interface{}{"arg1"})
	if err == nil {
		t.Error("Action without HTTP client should error")
	}
	if result != nil {
		t.Errorf("Action should return nil result on error, got %v", result)
	}
}

// ============================================================================
// SetProps — no HTTP client
// ============================================================================

func TestSetProps_NoHTTP(t *testing.T) {
	c := NewMIoTClient("test", nil, "uid", "cn", CtrlModeCloud)
	defer c.Stop()

	params := []PropParam{
		{DID: "did1", Siid: 2, Piid: 1, Value: "val1"},
		{DID: "did2", Siid: 3, Piid: 2, Value: "val2"},
	}

	results, err := c.SetProps(params)
	if err == nil {
		t.Error("SetProps without HTTP client should error")
	}
	if results != nil {
		t.Errorf("SetProps should return nil results on error, got %v", results)
	}
}

// ============================================================================
// GetProps — no HTTP client
// ============================================================================

func TestGetProps_NoHTTP(t *testing.T) {
	c := NewMIoTClient("test", nil, "uid", "cn", CtrlModeCloud)
	defer c.Stop()

	params := []PropParam{
		{DID: "did1", Siid: 2, Piid: 1},
	}

	results, err := c.GetProps(params)
	if err == nil {
		t.Error("GetProps without HTTP client should error")
	}
	if results != nil {
		t.Errorf("GetProps should return nil results on error, got %v", results)
	}
}

// ============================================================================
// SetProp — correct param construction (needs mock HTTP, coverage test)
// ============================================================================

func TestSetProp_WithHTTP(t *testing.T) {
	// This test verifies that SetProp correctly constructs PropParam
	// and calls the HTTP client. Since we can't easily mock without
	// httptest, we verify the code path is correct.
	//
	// The http field on MIoTClient is an interface{} or *MIoTHttpClient.
	// In a real integration test, you'd mock the API endpoint.

	// Verifying the pattern: PropParam slice with 1 element
	param := PropParam{DID: "did1", Siid: 2, Piid: 1, Value: true}
	params := []PropParam{param}
	if len(params) != 1 {
		t.Fatal("param construction wrong")
	}
	if params[0].DID != "did1" || params[0].Siid != 2 || params[0].Piid != 1 {
		t.Error("PropParam fields wrong")
	}
	if params[0].Value != true {
		t.Error("PropParam Value wrong")
	}
}

func TestGetProp_ParamConstruction(t *testing.T) {
	param := PropParam{DID: "did1", Siid: 2, Piid: 1}
	if param.DID != "did1" {
		t.Error("DID wrong")
	}
	if param.Siid != 2 {
		t.Error("Siid wrong")
	}
	if param.Piid != 1 {
		t.Error("Piid wrong")
	}
}

// ============================================================================
// PropParam / PropResult types
// ============================================================================

func TestPropParam_Defaults(t *testing.T) {
	p := PropParam{}
	if p.DID != "" {
		t.Errorf("DID default = %q, want empty", p.DID)
	}
	if p.Siid != 0 {
		t.Errorf("Siid default = %d, want 0", p.Siid)
	}
	if p.Piid != 0 {
		t.Errorf("Piid default = %d, want 0", p.Piid)
	}
}

func TestPropResult_Defaults(t *testing.T) {
	r := PropResult{}
	if r.DID != "" {
		t.Errorf("DID default = %q, want empty", r.DID)
	}
	if r.Code != 0 {
		t.Errorf("Code default = %d, want 0", r.Code)
	}
}