package main

import (
    "fmt"
    "log"
    "time"

    "github.com/Netsocs-Team/driver.sdk_go/pkg/client"
    "github.com/Netsocs-Team/driver.sdk_go/pkg/config"
    "github.com/Netsocs-Team/driver.sdk_go/pkg/objects"
)

func main() {
    // Initialize SDK client
    c, err := client.New()
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    // Register configuration handlers
    c.AddConfigHandler(config.ACTION_PING_DEVICE, handlePing)
    c.AddConfigHandler(config.REQUEST_CREATE_OBJECTS, handleCreateObjects(c))

    // Start listening for platform requests
    log.Println("Driver ready, listening for requests...")
    c.ListenConfig()
}

func handlePing(msg config.HandlerValue) (interface{}, error) {
    // Test device connectivity
    return map[string]interface{}{
        "status": true,
        "msg":    "Device is online",
    }, nil
}

func handleCreateObjects(c *client.NetsocsDriverClient) config.FuncConfigHandler {
    return func(msg config.HandlerValue) (interface{}, error) {
        // Create temperature sensor
        sensor := objects.NewSensorObject(objects.NewSensorObjectParams{
            Metadata: objects.ObjectMetadata{
                ObjectID: "temp_sensor_01",
                Name:     "Living Room Temperature",
                Domain:   "temperature",
                DeviceID: msg.DeviceData.ID,
            },
            SetupFn: func(obj objects.RegistrableObject, oc objects.ObjectController) error {
                sensor := obj.(objects.SensorObject)
                sensor.SetSensorType(objects.SensorObjectTypeNumber)
                sensor.SetUnitOfMeasurement("°C")
                sensor.SetState(objects.SENSOR_STATE_MEASUREMENT)
                sensor.SetValue("20.0")
                
                // Start temperature updates
                go updateTemperature(sensor)
                return nil
            },
        })

        // Register with platform
        return nil, c.RegisterObject(sensor)
    }
}

func updateTemperature(sensor objects.SensorObject) {
    ticker := time.NewTicker(10 * time.Second)
    defer ticker.Stop()
    
    temperature := 20.0
    for range ticker.C {
        temperature += (float64(time.Now().Unix()%3) - 1) * 0.5
        sensor.SetValue(fmt.Sprintf("%.1f", temperature))
    }
}

// Register camera objects
camera := objects.NewVideoChannelObject(objects.NewVideoChannelObjectProps{
    Metadata: objects.ObjectMetadata{
        ObjectID: "camera_ch1",
        Name:     "Front Entrance Camera",
        Domain:   "camera",
        DeviceID: "nvr_001",
    },
    StreamID:    "rtsp://192.168.1.10:554/stream1",
    VideoEngine: "video_engine_01",
    PTZ:         true,
    SnapshotFn: func(vc objects.VideoChannelObject, oc objects.ObjectController,
                     payload objects.SnapshotActionPayload) (string, error) {
        // Capture and upload snapshot
        imageURL, err := captureSnapshot(vc.GetMetadata().ObjectID)
        return imageURL, err
    },
})

// Register reader object
reader := objects.NewReaderObject(objects.NewReaderObjectParams{
    Metadata: objects.ObjectMetadata{
        ObjectID: "reader_main_entrance",
        Name:     "Main Entrance Reader",
        Domain:   "access_control",
        DeviceID: "ac_panel_001",
    },
    SupportedCredentialTypes: []string{"card", "face", "fingerprint"},
})

// Dispatch access events
eventData := objects.Event{
    ObjectIDs: []string{"reader_main_entrance"},
    Properties: map[string]string{
        "user_id":     "12345",
        "credential":  "card",
        "result":      "granted",
        "door_id":     "main_door",
    },
}
client.DispatchEvent("access_control", "access_granted", eventData)

// Register alarm panel
panel := objects.NewAlarmPanelObject(objects.NewAlarmPanelObjectProps{
    Metadata: objects.ObjectMetadata{
        ObjectID: "alarm_panel_main",
        Name:     "Main Security Panel",
        Domain:   "alarm",
        DeviceID: "panel_001",
    },
})

// Register zone sensors
for _, zone := range zones {
    sensor := objects.NewSensorObject(objects.NewSensorObjectParams{
        Metadata: objects.ObjectMetadata{
            ObjectID: fmt.Sprintf("zone_%s", zone.ID),
            Name:     zone.Name,
            Domain:   "alarm",
            DeviceID: "panel_001",
            ParentID: "alarm_panel_main",
        },
    })
    client.RegisterObject(sensor)
}

func TestPingHandler(t *testing.T) {
    handler := handlePingDevice(mockDeviceManager)
    
    msg := config.HandlerValue{
        DeviceData: config.DeviceData{
            IP:   "192.168.1.100",
            Port: 80,
        },
    }
    
    response, err := handler(msg)
    assert.NoError(t, err)
    
    result := response.(map[string]interface{})
    assert.True(t, result["status"].(bool))
}