backend_vib360_laravel/app/Http/Controllers/APIS/CustomerApi/TelemetryController.php

<?php

namespace App\Http\Controllers\APIS\CustomerApi;

use App\Http\Controllers\Controller;
use App\Models\Asset;
use App\Models\Device;
use App\Models\TimeseriesKeyMaster;
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\Validator;

class TelemetryController extends Controller
{
    protected $customerInfoService;

    public function __construct(CustomerInfoService $customerInfoService)
    {
        $this->customerInfoService = $customerInfoService;
    }



    public function telemetryDataAsset(Request $request)
    {
        try {
            // Read and validate token first
            $token = readHeaderToken();
            if (!$token) {
                return response()->json([
                    'success' => false,
                    'error' => 'Authorization token required'
                ], 401);
            }

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

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

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

            // Get devices with their profiles and timeseries keys
            $devices = Device::with(['deviceProfile', 'timeseriesKeys' => function($query) {
                $query->where('display_on_dashboard', true)
                      ->orWhere('display_on_popup', true)
                      ->select(['key_name', 'display_name', 'display_on_dashboard', 'display_on_popup', 'device_profile_xid']);
            }])
            ->where('asset_id', $assetId)
            ->get();

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

            // Prepare data for bulk telemetry request
            $deviceIds = $devices->pluck('id');
            $allKeyNames = TimeseriesKeyMaster::whereIn('device_profile_xid', $devices->pluck('device_profile_id'))
                ->where(function($query) {
                    $query->where('display_on_dashboard', true)
                          ->orWhere('display_on_popup', true);
                })
                ->pluck('key_name')
                ->unique()
                ->toArray();

            // Get telemetry data with token
            $bulkTelemetry = $this->customerInfoService->getTelemetryData(
                $deviceIds,
                $allKeyNames,
                $startTs,
                $endTs,
                $token  // Pass the token to the service
            );

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

            // Format the response
            $response = $devices->map(function($device) use ($bulkTelemetry) {
                $telemetry = collect();

                foreach ($device->timeseriesKeys as $keyData) {
                    $keyName = $keyData->key_name;

                    if (isset($bulkTelemetry[$device->id][$keyName])) {
                        $telemetry = $telemetry->merge(
                            collect($bulkTelemetry[$device->id][$keyName])->map(function($item) use ($keyData) {
                                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'           => $item['ts'] ?? null,
                                    'value'               => $item['value'] ?? null,
                                ];
                            })
                        );
                    }
                }

                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->values()->all(),
                ];
            });

            return response()->json([
                'success' => true,
                'telemetry' => $response
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'error' => 'Failed to fetch telemetry data',
                'details' => config('app.debug') ? $e->getMessage() : null
            ], 500);
        }
    }

    public function telemetryDataDevice(Request $request)
    {
        try {
            // Read and validate token first
            $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');
            $endTs = $request->input('endTs');

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

                // Pass the token to the service method
                $telemetryResponse = $this->customerInfoService->getTelemetryDataDevice(
                    $deviceWithTelemetry,
                    $deviceWithTelemetry->timeseriesKeys->pluck('key_name')->toArray(),
                    $startTs,
                    $endTs,
                    $token  // Added token parameter
                );

                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,
                            ];
                        });
                    })
                    ->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 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]);
    // }

}