<?php

namespace App\Http\Controllers\APIS\CustomerApi;

use App\Http\Controllers\Controller;
use App\Models\Asset;
use App\Models\Customer;
use App\Models\Device;
use App\Models\TimeseriesAlertMessage;
use App\Models\TimeseriesKeyMaster;
use App\Models\User;
use App\Services\AlarmService;
use App\Services\CustomerInfoService;
use Illuminate\Container\Attributes\DB;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB as FacadesDB;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;

class TelemetryController extends Controller
{
    protected $customerInfoService, $alarmService;

    // public function __construct(CustomerInfoService $customerInfoService)
    // {
    //     $this->customerInfoService = $customerInfoService;
    // }
    public function __construct(CustomerInfoService $customerInfoService, AlarmService $alarmService)
    {
        $this->customerInfoService = $customerInfoService;
        $this->alarmService = $alarmService;  // 💡 Add AlarmService
    }


    // public function telemetryDataAsset(Request $request)
    // {
    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //         'startTs'  => 'nullable|string',
    //         'endTs'    => 'nullable|string',
    //     ]);

    //     if ($validator->fails()) {
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');
    //     $startTs = $request->input('startTs') ?: now()->subHours(24)->timestamp * 1000;  // Default: last 24 hrs
    //     $endTs = $request->input('endTs') ?: now()->timestamp * 1000;

    //     $devices = Device::with('deviceProfile')
    //         ->where('asset_id', $assetId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $filteredTelemetry = [];

    //         // Fetch telemetry data
    //         $keysData = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->where('display_on_dashboard', 1)
    //             ->get(['key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);

    //         $keyNames = $keysData->pluck('key_name')->toArray();

    //         // Retrieve telemetry data
    //         $telemetryResponse = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTs, $endTs);

    //         foreach ($keysData as $keyData) {
    //             $keyName = $keyData->key_name;

    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     // 💡 Check alert status for each telemetry key
    //                     $alert = $this->checkTelemetryKeyAlert($device->id, $keyName);

    //                     $filteredTelemetry[] = [
    //                         'key_name'            => $keyName,
    //                         'display_name'        => $keyData->display_name,
    //                         'display_on_dashboard' => $keyData->display_on_dashboard,
    //                         'display_on_popup'    => $keyData->display_on_popup,
    //                         'timestamp'           => $item['ts'] ?? null,
    //                         'value'               => $item['value'] ?? null,
    //                         'alert'               => $alert  // ✅ Add alert status for each key
    //                     ];
    //                 }
    //             }
    //         }

    //         $response[] = [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => $filteredTelemetry,
    //         ];
    //     }

    //     return response()->json(['telemetry' => $response]);
    // }


    // public function telemetryDataAsset(Request $request)
    // {
    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //         'startTs'  => 'nullable|string',
    //         'endTs'    => 'nullable|string',
    //     ]);

    //     if ($validator->fails()) {
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');
    //     $startTs = $request->input('startTs') ?: null;
    //     $endTs = $request->input('endTs') ?: null;

    //     // Fetch devices associated with the asset
    //     $devices = Device::with('deviceProfile')
    //         ->where('asset_id', $assetId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $telemetry = [];

    //         $keysData = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->where(function ($query) {
    //                 $query->where('display_on_dashboard', true)
    //                     ->orWhere('display_on_popup', true);
    //             })
    //             ->get(['key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);

    //         $keyNames = $keysData->pluck('key_name')->toArray();

    //         // Log key names for debugging
    //         // Log::info('Key Names for Device', ['device_id' => $device->id, 'key_names' => $keyNames]);

    //         // Fetch telemetry data
    //         $telemetryResponse = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTs, $endTs);

    //         foreach ($keysData as $keyData) {
    //             $keyName = $keyData->key_name;

    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     $telemetry[] = [
    //                         'key_name'            => $keyName,
    //                         'display_name'        => $keyData->display_name,
    //                         'display_on_dashboard' => $keyData->display_on_dashboard,
    //                         'display_on_popup'    => $keyData->display_on_popup,
    //                         'timestamp'           => $item['ts'] ?? null,
    //                         'value'               => $item['value'] ?? null,
    //                     ];
    //                 }
    //             }
    //         }

    //         $response[] = [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => $telemetry,
    //         ];
    //     }

    //     return response()->json(['telemetry' => $response]);
    // }


    // public function telemetryDataAsset(Request $request)
    // {
    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //         'startTs'  => 'nullable|string',
    //         'endTs'    => 'nullable|string',
    //     ]);

    //     if ($validator->fails()) {
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');
    //     $startTs = $request->input('startTs') ?: now()->subHours(24)->timestamp * 1000;  // Default: last 24 hrs
    //     $endTs = $request->input('endTs') ?: now()->timestamp * 1000;

    //     $devices = Device::with('deviceProfile')
    //         ->where('asset_id', $assetId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $telemetry = [];

    //         // Fetch telemetry keys
    //         $keysData = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->where(function ($query) {
    //                 $query->where('display_on_dashboard', true)
    //                     ->orWhere('display_on_popup', true);
    //             })
    //             ->get(['key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);

    //         $keyNames = $keysData->pluck('key_name')->toArray();

    //         // Fetch telemetry data
    //         $telemetryResponse = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTs, $endTs);

    //         // Fetch alarms for the device and map by telemetry key
    //         $alarmMap = $this->getDeviceAlarmsForTelemetry($device->id);

    //         foreach ($keysData as $keyData) {
    //             $keyName = $keyData->key_name;

    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     // Check if the telemetry key has an alarm
    //                     $alert = isset($alarmMap[$keyName]);

    //                     $telemetry[] = [
    //                         'key_name'            => $keyName,
    //                         'display_name'        => $keyData->display_name,
    //                         'display_on_dashboard' => $keyData->display_on_dashboard,
    //                         'display_on_popup'    => $keyData->display_on_popup,
    //                         'timestamp'           => $item['ts'] ?? null,
    //                         'value'               => $item['value'] ?? null,
    //                         'alert'               => $alert  // ✅ Display alert status
    //                     ];
    //                 }
    //             }
    //         }

    //         $response[] = [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => $telemetry,
    //         ];
    //     }

    //     return response()->json(['telemetry' => $response]);
    // }

    // public function telemetryDataAsset(Request $request)
    // {
    //     Log::info("Received telemetryDataAsset request.", $request->all());

    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //         'startTs'  => 'nullable|string',
    //         'endTs'    => 'nullable|string',
    //     ]);

    //     if ($validator->fails()) {
    //         Log::error("Validation failed: " . $validator->errors()->first());
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');
    //     $startTs = $request->input('startTs') ?: now()->subHours(24)->timestamp * 1000;  // Default: last 24 hrs
    //     $endTs = $request->input('endTs') ?: now()->timestamp * 1000;

    //     Log::info("Telemetry time range: Start => {$startTs}, End => {$endTs}");

    //     // Fetch devices associated with the asset
    //     $devices = Device::with('deviceProfile')
    //         ->where('asset_id', $assetId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         Log::warning("No devices found for asset ID: {$assetId}");
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     Log::info("Found " . $devices->count() . " devices for asset ID: {$assetId}");

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $telemetry = [];

    //         Log::info("Processing device ID: {$device->id}");

    //         // Fetch telemetry keys
    //         $keysData = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->where(function ($query) {
    //                 $query->where('display_on_dashboard', true)
    //                     ->orWhere('display_on_popup', true);
    //             })
    //             ->get(['key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);

    //         Log::info("Fetched " . $keysData->count() . " telemetry keys for device ID: {$device->id}");

    //         $keyNames = $keysData->pluck('key_name')->toArray();

    //         // Fetch telemetry data
    //         $telemetryResponse = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTs, $endTs);

    //         Log::info("Fetched telemetry data for device ID: {$device->id}");

    //         // Fetch alarms for the device and map by telemetry key
    //         $alarmMap = $this->getDeviceAlarmsForTelemetry($device->id);
    //         Log::info("Fetched alarms for device ID: {$device->id}", $alarmMap);

    //         foreach ($keysData as $keyData) {
    //             $keyName = $keyData->key_name;

    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     // Check if the telemetry key has an alarm
    //                     $alert = isset($alarmMap[$keyName]);

    //                     $telemetry[] = [
    //                         'key_name'            => $keyName,
    //                         'display_name'        => $keyData->display_name,
    //                         'display_on_dashboard' => $keyData->display_on_dashboard,
    //                         'display_on_popup'    => $keyData->display_on_popup,
    //                         'timestamp'           => $item['ts'] ?? null,
    //                         'value'               => $item['value'] ?? null,
    //                         'alert'               => $alert  // ✅ Display alert status
    //                     ];
    //                 }
    //             }
    //         }

    //         $response[] = [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => $telemetry,
    //         ];

    //         Log::info("Processed telemetry for device ID: {$device->id}");
    //     }

    //     Log::info("Telemetry data successfully generated for asset ID: {$assetId}");

    //     return response()->json(['telemetry' => $response]);
    // }

    // public function telemetryDataAsset(Request $request)
    // {
    //     $token = readHeaderToken();
    //     $customerId = User::where('id', $token['sub'])->value('customer_id');

    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //         'startTs'  => 'nullable|string',
    //         'endTs'    => 'nullable|string',
    //     ]);

    //     if ($validator->fails()) {
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');
    //     $startTs = $request->input('startTs') ?: now()->subHours(24)->timestamp * 1000;
    //     $endTs = $request->input('endTs') ?: now()->timestamp * 1000;

    //     $devices = Device::with([
    //         'deviceProfile',
    //         'timeseriesKeys' => function ($query) {
    //             $query->where('display_on_dashboard', true)
    //                 ->orWhere('display_on_popup', true)
    //                 ->select(['id', 'device_profile_xid', 'key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);
    //         }
    //     ])->where('asset_id', $assetId)
    //         ->where('customer_id', $customerId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     $response = $devices->map(function ($device) use ($startTs, $endTs) {
    //         $keysData = $device->timeseriesKeys;

    //         $keyNames = $keysData->pluck('key_name')->toArray();
    //         $telemetryResponse = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTs, $endTs);

    //         $alarmMap = $this->getDeviceAlarmsForTelemetry($device->id);

    //         $alertMessages = TimeseriesAlertMessage::whereIn('timeseries_key_master_xid', $keysData->pluck('id'))
    //             ->orderBy('min_value', 'asc')
    //             ->get()
    //             ->groupBy('timeseries_key_master_xid');
    //         $telemetry = $keysData->map(function ($keyData) use ($telemetryResponse, $alarmMap, $alertMessages) {
    //             return collect($telemetryResponse[$keyData->key_name] ?? [])->map(function ($item) use ($keyData, $alarmMap, $alertMessages) {
    //                 $keyName = $keyData->key_name;
    //                 $alert = isset($alarmMap[$keyName]);
    //                 $value = floatval($item['value'] ?? 0);
    //                 $colorCode = null;

    //                 // Default to grey if value is 0
    //                 if ($value == 0) {
    //                     $colorCode = "grey";
    //                 } else {
    //                     // Check alert messages for this key
    //                     if (isset($alertMessages[$keyData->id])) {
    //                         foreach ($alertMessages[$keyData->id] as $alertMsg) {
    //                             // If min_value or max_value is null, return null
    //                             if (is_null($alertMsg->min_value) || is_null($alertMsg->max_value)) {
    //                                 $colorCode = 'green';
    //                                 break;
    //                             }

    //                             if ($value >= floatval($alertMsg->min_value) && $value <= floatval($alertMsg->max_value)) {
    //                                 $colorCode = $alertMsg->color_code;
    //                                 break;
    //                             }
    //                         }
    //                     }
    //                 }

    //                 return [
    //                     'key_name'             => $keyName,
    //                     'display_name'         => $keyData->display_name,
    //                     'display_on_dashboard' => $keyData->display_on_dashboard,
    //                     'display_on_popup'     => $keyData->display_on_popup,
    //                     'timestamp'            => $item['ts'] ?? null,
    //                     'value'                => $value,
    //                     'alert'                => $alert,
    //                     'color_code'           => $colorCode, // Now handles null & grey cases
    //                 ];
    //             });
    //         })->flatten(1);

    //         return [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => array_values($telemetry->toArray()),
    //         ];
    //     });

    //     return response()->json(['telemetry' => $response]);
    // }


    // public function telemetryDataAsset(Request $request)
    // {
    //     $token = readHeaderToken();
    //     $customerId = User::where('id', $token['sub'])->value('customer_id');

    //     $validator = Validator::make($request->all(), [
    //         'asset_id' => 'required|string',
    //     ]);

    //     if ($validator->fails()) {
    //         return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    //     }

    //     $assetId = $request->input('asset_id');

    //     // Set timestamps in milliseconds for database query
    //     $endTsMs = now()->timestamp * 1000; // Current time in milliseconds
    //     $startTsMs = $endTsMs - (30 * 60 * 1000); // 5 minutes ago in milliseconds

    //     $devices = Device::with([
    //         'deviceProfile',
    //         'timeseriesKeys' => function ($query) {
    //             $query->where('display_on_dashboard', true)
    //                 ->orWhere('display_on_popup', true)
    //                 ->select(['id', 'device_profile_xid', 'key_name', 'display_name', 'display_on_dashboard', 'display_on_popup']);
    //         }
    //     ])->where('asset_id', $assetId)
    //       ->where('customer_id', $customerId)
    //       ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found for the asset'], 404);
    //     }

    //     $response = $devices->map(function ($device) use ($startTsMs, $endTsMs) {
    //         $keysData = $device->timeseriesKeys;
    //         $keyNames = $keysData->pluck('key_name')->toArray();

    //         // Get telemetry data for start and end times
    //         $startTelemetry = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTsMs, $startTsMs);
    //         $endTelemetry = $this->customerInfoService->getTelemetryData($device, $keyNames, $endTsMs, $endTsMs);

    //         $alarmMap = $this->getDeviceAlarmsForTelemetry($device->id);
    //         $alertMessages = TimeseriesAlertMessage::whereIn('timeseries_key_master_xid', $keysData->pluck('id'))
    //             ->orderBy('min_value', 'asc')
    //             ->get()
    //             ->groupBy('timeseries_key_master_xid');

    //         $telemetry = $keysData->map(function ($keyData) use ($startTelemetry, $endTelemetry, $alarmMap, $alertMessages) {
    //             $startData = collect($startTelemetry[$keyData->key_name] ?? [])->last();
    //             $endData = collect($endTelemetry[$keyData->key_name] ?? [])->last();

    //             $startValue = floatval($startData['value'] ?? 0);
    //             $endValue = floatval($endData['value'] ?? 0);

    //             // Determine trend based on start vs end values
    //             $trend = null;
    //             if ($startValue > 0) {
    //                 if ($endValue > $startValue) {
    //                     $trend = 'upward';
    //                 } elseif ($endValue < $startValue) {
    //                     $trend = 'downward';
    //                 } else {
    //                     $trend = 'stable';
    //                 }
    //             }

    //             // Format timestamp properly (convert to seconds if in milliseconds)
    //             if (!isset($currentData['ts'])) {
    //                 $timestamp = now()->timestamp;
    //             } elseif (is_float($currentData['ts']) || $currentData['ts'] > 9999999999) {
    //                 $timestamp = intval($currentData['ts'] / 1000);
    //             } else {
    //                 $timestamp = $currentData['ts'];
    //             }

    //             // Color code logic
    //             $colorCode = null;
    //             if ($endValue == 0) {
    //                 $colorCode = "grey";
    //             } else {
    //                 if (isset($alertMessages[$keyData->id])) {
    //                     foreach ($alertMessages[$keyData->id] as $alertMsg) {
    //                         if (is_null($alertMsg->min_value) || is_null($alertMsg->max_value)) {
    //                             $colorCode = 'green';
    //                             break;
    //                         }
    //                         if ($endValue >= floatval($alertMsg->min_value) && $endValue <= floatval($alertMsg->max_value)) {
    //                             $colorCode = $alertMsg->color_code;
    //                             break;
    //                         }
    //                     }
    //                 }
    //             }

    //             return [
    //                 'key_name'             => $keyData->key_name,
    //                 'display_name'         => $keyData->display_name,
    //                 'display_on_dashboard' => $keyData->display_on_dashboard,
    //                 'display_on_popup'     => $keyData->display_on_popup,
    //                 'timestamp'            => $timestamp,
    //                 'value'                => $endValue,
    //                 'start_value'          => $startValue > 0 ? $startValue : null,
    //                 'trend'                => $trend,
    //                 'alert'                => isset($alarmMap[$keyData->key_name]),
    //                 'color_code'           => $colorCode,
    //             ];
    //         })->filter()->values();

    //         return [
    //             'device_id'           => (string) $device->id,
    //             'device_profile_name' => (string) $device->deviceProfile->name,
    //             'asset_id'            => (string) $device->asset_id,
    //             'device_profile_id'   => (string) $device->device_profile_id,
    //             'telemetry'           => $telemetry,
    //         ];
    //     });

    //     return response()->json([
    //         'telemetry' => $response,
    //         'time_range' => [
    //             'startTs' => intval($startTsMs / 1000), // Current period start (seconds)
    //             'endTs' => intval($endTsMs / 1000),     // Current period end (seconds)
    //         ]
    //     ]);
    // }

    public function telemetryDataAsset(Request $request)
{
    // Get authenticated user's customer ID
    $token = readHeaderToken();
    $customerId = User::where('id', $token['sub'])->value('customer_id');
    dd($customerId);

    if (!$customerId) {
        return response()->json(['error' => 'Unauthorized - Invalid user'], 401);
    }

    // Validate request
    $validator = Validator::make($request->all(), [
        'asset_id' => 'required|string',
    ]);

    if ($validator->fails()) {
        return jsonResponseWithErrorMessage($validator->errors()->first(), 400);
    }

    $assetId = $request->input('asset_id');

    $assetExists = Asset::where('id', $assetId)
                      ->where('customer_xid', $customerId)->exists();

                    //   dd($assetExists);

    if (!$assetExists) {
        return response()->json(['error' => 'Asset not found or access denied'], 404);
    }

    // Set timestamps in milliseconds for database query
    $endTsMs = now()->timestamp * 1000; // Current time in milliseconds
    $startTsMs = $endTsMs - (30 * 60 * 1000); // 30 minutes ago in milliseconds

    // Get devices that belong to both the asset and customer
    $devices = Device::with([
            'deviceProfile:id,name',
            'timeseriesKeys' => function ($query) {
                $query->where('display_on_dashboard', true)
                    ->orWhere('display_on_popup', true)
                    ->select(['id', 'device_profile_xid', 'key_name', 'display_name',
                             'display_on_dashboard', 'display_on_popup']);
            }
        ])
        ->where('asset_id', $assetId)
        ->where('customer_id', $customerId)
        ->select(['id', 'device_profile_id', 'asset_id', 'customer_id'])
        ->get();

    if ($devices->isEmpty()) {
        return response()->json(['error' => 'No devices found for this asset'], 404);
    }

    $response = $devices->map(function ($device) use ($startTsMs, $endTsMs) {
        $keysData = $device->timeseriesKeys;
        $keyNames = $keysData->pluck('key_name')->toArray();

        // Get telemetry data for start and end times
        $startTelemetry = $this->customerInfoService->getTelemetryData($device, $keyNames, $startTsMs, $startTsMs);
        $endTelemetry = $this->customerInfoService->getTelemetryData($device, $keyNames, $endTsMs, $endTsMs);

        $alarmMap = $this->getDeviceAlarmsForTelemetry($device->id);
        $alertMessages = TimeseriesAlertMessage::whereIn('timeseries_key_master_xid', $keysData->pluck('id'))
            ->orderBy('min_value', 'asc')
            ->get()
            ->groupBy('timeseries_key_master_xid');

        $telemetry = $keysData->map(function ($keyData) use ($startTelemetry, $endTelemetry, $alarmMap, $alertMessages) {
            $startData = collect($startTelemetry[$keyData->key_name] ?? [])->last();
            $endData = collect($endTelemetry[$keyData->key_name] ?? [])->last();

            $startValue = floatval($startData['value'] ?? 0);
            $endValue = floatval($endData['value'] ?? 0);

            // Determine trend
            $trend = null;
            if ($startValue > 0) {
                if ($endValue > $startValue) {
                    $trend = 'upward';
                } elseif ($endValue < $startValue) {
                    $trend = 'downward';
                } else {
                    $trend = 'stable';
                }
            }

            // Format timestamp
            $timestamp = now()->timestamp;
            if (isset($endData['ts'])) {
                $timestamp = ($endData['ts'] > 9999999999) ? intval($endData['ts'] / 1000) : $endData['ts'];
            }

            $colorCode = null;
            if ($endValue != 0 && isset($alertMessages[$keyData->id])) {
                foreach ($alertMessages[$keyData->id] as $alertMsg) {
                    if (is_null($alertMsg->min_value) && is_null($alertMsg->max_value)) {
                        $colorCode = 'green';
                        break;
                    }
                    if ($endValue >= floatval($alertMsg->min_value) && $endValue <= floatval($alertMsg->max_value)) {
                        $colorCode = $alertMsg->color_code;
                        break;
                    }
                }
            }

            return [
                'key_name'             => $keyData->key_name,
                'display_name'         => $keyData->display_name,
                'display_on_dashboard' => $keyData->display_on_dashboard,
                'display_on_popup'     => $keyData->display_on_popup,
                'timestamp'            => $timestamp,
                'value'                => $endValue,
                'start_value'          => $startValue > 0 ? $startValue : null,
                'trend'                => $trend,
                'alert'                => isset($alarmMap[$keyData->key_name]),
                'color_code'           => $colorCode ?: ($endValue == 0 ? 'grey' : 'green'),
            ];
        })->filter()->values();

        return [
            'device_id'           => (string) $device->id,
            'device_profile_name' => (string) $device->deviceProfile->name,
            'asset_id'            => (string) $device->asset_id,
            'device_profile_id'   => (string) $device->device_profile_id,
            'telemetry'           => $telemetry,
        ];
    });

    return response()->json([
        'telemetry' => $response,
        'time_range' => [
            'startTs' => intval($startTsMs / 1000),
            'endTs' => intval($endTsMs / 1000),
        ]
    ]);
}

    private function getDeviceAlarmsForTelemetry($deviceId)
    {
        Log::info("Fetching alarms for device: {$deviceId}");

        $pageSize = 1000;
        $page = 0;

        // Fetch ThingsBoard token
        $token = $this->alarmService->getToken();
        if (!$token) {
            Log::error("Failed to fetch ThingsBoard token.");
            return [];
        }
        Log::info("Token fetched successfully.");

        $baseUrl = env('THINGSBOARD_URL');

        $endTime = now()->timestamp * 1000;                         // Current time in ms
        $startTime = now()->subHours(24)->timestamp * 1000;         // 24 hours ago in ms

        Log::info("Time range: Start => {$startTime}, End => {$endTime}");

        // Fetch alarms from ThingsBoard API
        try {
            $response = Http::withHeaders([
                'Authorization' => "Bearer $token",
                'Accept'        => 'application/json',
            ])->get("$baseUrl/api/v2/alarms", [
                'statusList'   => 'ACTIVE',
                'severityList' => 'CRITICAL,MAJOR,MINOR,WARNING',
                'pageSize'     => $pageSize,
                'page'         => $page,
                'startTime'    => $startTime,
                'endTime'      => $endTime,
                'sortProperty' => 'createdTime',
                'sortOrder'    => 'DESC',
                'originator'   => $deviceId   // Filter by device ID
            ]);

            if (!$response->successful()) {
                Log::error("Failed to fetch alarms. Status: " . $response->status());
                return [];
            }

            // Parse the response
            $alarms = $response->json()['data'] ?? [];
            Log::info("Fetched " . count($alarms) . " alarms for device ID: {$deviceId}");

            // Map alarms by `type` field
            $alarmMap = [];
            foreach ($alarms as $alarm) {
                if (isset($alarm['type'])) {
                    $alarmMap[$alarm['type']] = true;
                }
            }

            Log::info("Mapped alarm types: ", $alarmMap);

            return $alarmMap;
        } catch (\Exception $e) {
            Log::error("Error fetching alarms: " . $e->getMessage());
            return [];
        }
    }


    // public function telemetryDataDevice(Request $request)
    // {
    //     try {

    //         $token = readHeaderToken();
    //         if (!$token) {
    //             return response()->json([
    //                 'success' => false,
    //                 'error' => 'Authorization token required'
    //             ], 401);
    //         }

    //         $validator = Validator::make($request->all(), [
    //             'device_id' => 'required|string',
    //             'startTs'  => 'nullable|string',
    //             'endTs'    => 'nullable|string',
    //         ]);

    //         if ($validator->fails()) {
    //             return response()->json([
    //                 'success' => false,
    //                 'error' => $validator->errors()->first()
    //             ], 400);
    //         }

    //         $deviceId = $request->input('device_id');
    //         $startTs = $request->input('startTs') ?: null;
    //         $endTs = $request->input('endTs') ?: null;

    //         try {
    //             $deviceWithTelemetry = Device::with([
    //                 'deviceProfile',
    //                 'timeseriesKeys' => function ($query) {
    //                     $query->select('key_name', 'display_name', 'device_profile_xid', 'display_on_dashboard','display_on_dashboard');
    //                 }
    //             ])
    //                 ->where('id', $deviceId)
    //                 ->firstOrFail();

    //             $telemetryResponse = $this->customerInfoService->getTelemetryDataDevice(
    //                 $deviceWithTelemetry,
    //                 $deviceWithTelemetry->timeseriesKeys->pluck('key_name')->toArray(),
    //                 $startTs,
    //                 $endTs,
    //                 $token
    //             );

    //             if (!is_array($telemetryResponse)) {
    //                 throw new \Exception("Invalid telemetry data format received from service");
    //             }

    //             $telemetry = collect($telemetryResponse)
    //                 ->flatMap(function ($items, $keyName) use ($deviceWithTelemetry) {
    //                     $displayName = $deviceWithTelemetry->timeseriesKeys
    //                         ->firstWhere('key_name', $keyName)?->display_name ?? $keyName;

    //                     return collect($items)->map(function ($item) use ($keyName, $displayName) {
    //                         return [
    //                             'key_name' => $keyName,
    //                             'timestamp' => $item['ts'] ?? null,
    //                             'value' => $item['value'] ?? null,
    //                             'display_name' => $displayName,
    //                             'display_on_dashboard'
    //                         ];
    //                     });
    //                 })
    //                 ->values()
    //                 ->all();

    //             return response()->json([
    //                 'success' => true,
    //                 'telemetry' => [
    //                     'device_id' => (string) $deviceWithTelemetry->id,
    //                     'device_name' => $deviceWithTelemetry->name,
    //                     'device_profile_name' => $deviceWithTelemetry->deviceProfile->name,
    //                     'device_profile_id' => (string) $deviceWithTelemetry->device_profile_id,
    //                     'telemetry_data' => $telemetry,
    //                 ]
    //             ], 200);
    //         } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $e) {
    //             return response()->json([
    //                 'success' => false,
    //                 'error' => 'Device not found'
    //             ], 404);
    //         } catch (\Exception $e) {
    //             return response()->json([
    //                 'success' => false,
    //                 'error' => 'Failed to fetch telemetry data',
    //                 'details' => config('app.debug') ? $e->getMessage() : null
    //             ], 503);
    //         }
    //     } catch (\Exception $e) {
    //         return response()->json([
    //             'success' => false,
    //             'error' => 'Internal server error',
    //             'details' => config('app.debug') ? $e->getMessage() : null
    //         ], 500);
    //     }
    // }

    public function telemetryDataDevice(Request $request)
    {
        try {
            Log::info('Telemetry request received', ['request_data' => $request->all()]);

            $token = readHeaderToken();
            if (!$token) {
                Log::warning('Unauthorized access attempt: Missing token');
                return response()->json([
                    'success' => false,
                    'error'   => 'Authorization token required'
                ], 401);
            }

            $validator = Validator::make($request->all(), [
                'device_id' => 'required|string',
                'startTs'   => 'nullable|string',
                'endTs'     => 'nullable|string',
            ]);

            if ($validator->fails()) {
                Log::error('Validation failed', ['errors' => $validator->errors()]);
                return response()->json([
                    'success' => false,
                    'error'   => $validator->errors()->first()
                ], 400);
            }

            $deviceId = $request->input('device_id');
            $startTs = $request->input('startTs') ?: null;
            $endTs = $request->input('endTs') ?: null;

            try {
                Log::info('Fetching device telemetry', ['device_id' => $deviceId]);

                $deviceWithTelemetry = Device::with([
                    'deviceProfile',
                    'timeseriesKeys' => function ($query) {
                        $query->where(function ($q) {
                            $q->where('display_on_dashboard', true)
                                ->orWhere('display_on_popup', true);
                        })
                            ->select('key_name', 'display_name', 'device_profile_xid', 'display_on_dashboard', 'display_on_popup');
                    }
                ])
                    ->where('id', $deviceId)
                    ->firstOrFail();

                $displayKeys = $deviceWithTelemetry->timeseriesKeys->pluck('key_name')->toArray();
                $deviceProfileName = strtolower($deviceWithTelemetry->deviceProfile->name ?? '');

                Log::info('Device profile and keys retrieved', [
                    'device_profile' => $deviceProfileName,
                    'display_keys'   => $displayKeys
                ]);

                // Pressure key condition
                $pressureKey = 'Pressure_value';
                $pressureActive = false;

                $telemetryResponse = $this->customerInfoService->getTelemetryDataDevice(
                    $deviceWithTelemetry,
                    $displayKeys,
                    $startTs,
                    $endTs,
                    $token
                );

                if (!is_array($telemetryResponse)) {
                    Log::error('Invalid telemetry data format received');
                    throw new \Exception("Invalid telemetry data format received from service");
                }

                // Check if the device has "Gas Engine Profile" or "Engine Profile" in its profile name
                if (
                    (strpos($deviceProfileName, 'gas engine profile') !== false || strpos($deviceProfileName, 'engine profile') !== false)
                    && isset($telemetryResponse[$pressureKey])
                    && is_array($telemetryResponse[$pressureKey])
                ) {
                    foreach ($telemetryResponse[$pressureKey] as $pressureData) {
                        if (!empty($pressureData['value']) && floatval($pressureData['value']) > 0) {
                            $pressureActive = true;
                            break;
                        }
                    }
                }

                Log::info('Telemetry data processed', [
                    'pressure_value' => $pressureActive,
                    'telemetry_keys'  => array_keys($telemetryResponse)
                ]);

                // Filter telemetry data based on display keys
                $filteredResponse = array_intersect_key($telemetryResponse, array_flip($displayKeys));

                // Add Pressure key if condition is met
                if (isset($telemetryResponse[$pressureKey])) {
                    $filteredResponse[$pressureKey] = $telemetryResponse[$pressureKey];
                }

                $telemetry = collect($filteredResponse)
                    ->flatMap(function ($items, $keyName) use ($deviceWithTelemetry) {
                        $keyData = $deviceWithTelemetry->timeseriesKeys->firstWhere('key_name', $keyName);

                        return collect($items)->map(function ($item) use ($keyName, $keyData) {
                            return [
                                'key_name'              => $keyName,
                                'timestamp'             => $item['ts'] ?? null,
                                'value'                 => $item['value'] ?? null,
                                'display_name'          => $keyData->display_name ?? $keyName,
                                'display_on_dashboard'  => $keyData->display_on_dashboard ?? false,
                                'display_on_popup'      => $keyData->display_on_popup ?? false
                            ];
                        });
                    })
                    ->values()
                    ->all();

                Log::info('Telemetry response successfully generated', ['device_id' => $deviceId]);

                return response()->json([
                    'success' => true,
                    'telemetry' => [
                        'device_id'            => (string) $deviceWithTelemetry->id,
                        'device_name'          => $deviceWithTelemetry->name,
                        'device_profile_name'  => $deviceWithTelemetry->deviceProfile->name,
                        'device_profile_id'    => (string) $deviceWithTelemetry->device_profile_id,
                        'pressure_value'      => $pressureActive, // Updated response
                        'telemetry_data'       => $telemetry,
                    ]
                ], 200);
            } catch (\Illuminate\Database\Eloquent\ModelNotFoundException $e) {
                Log::error('Device not found', ['device_id' => $deviceId]);
                return response()->json([
                    'success' => false,
                    'error'   => 'Device not found'
                ], 404);
            } catch (\Exception $e) {
                Log::error('Failed to fetch telemetry data', [
                    'device_id' => $deviceId,
                    'error'     => $e->getMessage()
                ]);
                return response()->json([
                    'success' => false,
                    'error'   => 'Failed to fetch telemetry data',
                    'details' => config('app.debug') ? $e->getMessage() : null
                ], 503);
            }
        } catch (\Exception $e) {
            Log::critical('Internal server error', ['error' => $e->getMessage()]);
            return response()->json([
                'success' => false,
                'error'   => 'Internal server error',
                'details' => config('app.debug') ? $e->getMessage() : null
            ], 500);
        }
    }


    // public function telemetryDataDeviceDiagnostic(Request $request, $deviceId)
    // {
    //     $devices = Device::with('deviceProfile')
    //         ->where('id', $deviceId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found'], 404);
    //     }

    //     $startTs = $request->has('start_date') ? strtotime($request->start_date) * 1000 : null;
    //     $endTs = $request->has('end_date') ? strtotime($request->end_date) * 1000 : null;

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $telemetry = [];

    //         $keyNames = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->pluck('key_name', 'display_name')
    //             ->toArray();

    //         $telemetryResponse = $this->customerInfoService->getTelemetryDataDeviceDiagonostic($device, $keyNames, $startTs, $endTs);

    //         foreach ($keyNames as $keyName) {
    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     $timestamp = $item['ts'] ?? null;

    //                     // ✅ Filter telemetry by timestamp range
    //                     if ($timestamp && $timestamp >= $startTs && $timestamp <= $endTs) {
    //                         $telemetry[] = [
    //                             'key_name'     => $keyName,
    //                             'timestamp'    => $timestamp,
    //                             'start_date'   => $startTs,
    //                             'end_date'     => $endTs,
    //                             'value'        => $item['value'] ?? null,
    //                             'display_name' => $keyName,
    //                         ];
    //                     }
    //                 }
    //             }
    //         }

    //         if (!empty($telemetry)) {
    //             $response[] = [
    //                 'device_id'           => (string) $device->id,
    //                 'device_name'         => $device->name,
    //                 'device_profile_name' => (string) $device->deviceProfile->name,
    //                 'device_profile_id'   => (string) $device->device_profile_id,
    //                 'telemetry'           => $telemetry,
    //             ];
    //         }
    //     }

    //     return response()->json(['telemetry' => $response]);
    // }

    //     public function telemetryDataDeviceDiagnostic(Request $request, $deviceId)
    // {
    //     // Fetch devices
    //     $devices = Device::with('deviceProfile')
    //         ->where('id', $deviceId)
    //         ->get();

    //     if ($devices->isEmpty()) {
    //         return response()->json(['error' => 'No devices found'], 404);
    //     }

    //     // Get start and end timestamps from request parameters
    //     $startTs = $request->has('start_date') ? strtotime($request->start_date) * 1000 : null;
    //     $endTs = $request->has('end_date') ? strtotime($request->end_date) * 1000 : null;

    //     if (!$startTs || !$endTs) {
    //         return response()->json(['error' => 'Start date and end date are required'], 400);
    //     }

    //     $response = [];

    //     foreach ($devices as $device) {
    //         $telemetry = [];

    //         $keyNames = TimeseriesKeyMaster::where('device_profile_xid', $device->device_profile_id)
    //             ->pluck('key_name', 'display_name')
    //             ->toArray();

    //         $telemetryResponse = $this->customerInfoService->getTelemetryDataDeviceDiagonostic($device, $keyNames, $startTs, $endTs);

    //         foreach ($keyNames as $displayName => $keyName) {
    //             if (isset($telemetryResponse[$keyName])) {
    //                 foreach ($telemetryResponse[$keyName] as $item) {
    //                     $itemTs = $item['timestamp'] ?? null;

    //                     // ✅ Filter only telemetry within the date range
    //                     if ($itemTs >= $startTs && $itemTs <= $endTs) {
    //                         $telemetry[] = [
    //                             'key_name'     => $keyName,
    //                             'value'        => $item['value'] ?? null,
    //                             'display_name' => $displayName,
    //                             'timestamp'    => $itemTs,
    //                             'start_date'   => $startTs,
    //                             'end_date'     => $endTs
    //                         ];
    //                     }
    //                 }
    //             }
    //         }

    //         if (!empty($telemetry)) {
    //             $response[] = [
    //                 'device_id'           => (string) $device->id,
    //                 'device_name'         => $device->name,
    //                 'device_profile_name' => (string) $device->deviceProfile->name,
    //                 'device_profile_id'   => (string) $device->device_profile_id,
    //                 'telemetry'           => $telemetry,
    //             ];
    //         }
    //     }

    //     return response()->json(['telemetry' => $response]);
    // }

}