src/Service/MeteomaticsWeatherService.php line 4920

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use PDO;
  6. use DateTime;
  7. use GuzzleHttp;
  8. use GuzzleHttp\Client;
  9. use GuzzleHttp\Exception;
  10. use App\Lib\ExcelGenerator;
  11. use App\Service\RedisCache;
  12. use Pimcore\Model\DataObject\Report;
  13. use GuzzleHttp\Exception\RequestException;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use DateTimeZone;
  17. class MeteomaticsWeatherService
  18. {
  19.     private $apiBaseUrlOG = MATEOMATICS_API_URL_OG;
  20.     private $apiBaseUrl = MATEOMATICS_API_URL;
  21.     private $username;
  22.     private $password;
  23.     private $redisCache;
  25.     public function __construct(RedisCache $redisCache)
  26.     {
  27.         $this->username = MATEOMATICS_API_USERNAME;
  28.         $this->password = MATEOMATICS_API_PASSWORD;
  29.         $this->redisCache = $redisCache;
  30.     }
  32.     /**
  33.      * Query Meteomatics API for time series data and return the parsed response
  34.      *
  35.      * @param DateTime $startDate The start date of the time series data
  36.      * @param DateTime $endDate The end date of the time series data
  37.      * @param string $resolution The time resolution of the data (e.g. PT1H for hourly data)
  38.      * @param float $lat The latitude of the location to query data for
  39.      * @param float $lon The longitude of the location to query data for
  40.      * @param int $hour The number of hours ahead to forecast (e.g. 1 for one hour ahead)
  41.      * @param string $format The format to request the data in (e.g. json)
  42.      * @return array The parsed response data
  43.      */
  44.     public function timeSeriesQueryMeteocache(DateTime $startDate, DateTime $endDate, $resolution, $lat, $lon, $hour, $format)
  45.     {
  46.         try {
  47.             $startDateStr = $startDate->format(DateTime::ISO8601);
  48.             $endDateStr = $endDate->format(DateTime::ISO8601);
  49.             $parameters = [
  50.                 'wind_speed_10m:kmh',
  51.                 'wind_dir_10m:d',
  52.                 't_2m:C',
  53.                 'precip_3h:mm',
  54.                 'weather_symbol_' . $hour . 'h:idx',
  55.                 'precip_type:idx',
  56.                 'sunrise:sql',
  57.                 'wind_speed_10m:kn'
  59.             ];
  60.             $parametersStr = implode(',', $parameters);
  62.             // Create unique Redis key
  63.             $keyParams = [
  64.                 $startDate->format(DateTime::ISO8601),
  65.                 $endDate->format(DateTime::ISO8601),
  66.                 $resolution,
  67.                 $lat,
  68.                 $lon,
  69.                 $hour,
  70.                 $format
  71.             ];
  72.             $redisKey = hash('sha256', implode('_', $keyParams));
  74.             // Try to get the weather forecast data from Redis cache
  75.             $data = $this->redisCache->get($redisKey);
  77.             if (!$data) {
  78.                 $url = "{$this->apiBaseUrl}/{$startDateStr}--{$endDateStr}:{$resolution}/{$parametersStr}/{$lat},{$lon}/" . $format . "?use_decluttered=true";
  80.                 //echo $url;exit;
  81.                 $client = new Client(['verify' => false]);
  82.                 $response = $client->request('GET', $url, [
  83.                     'auth' => [$this->username, $this->password],
  84.                     'connect_timeout' => 2,
  85.                     'headers' => [
  86.                         'User-Agent' => 'Meteomatics PHP connector (Guzzle)'
  87.                     ]
  88.                 ]);
  90.                 $statusCode = $response->getStatusCode();
  91.                 $data = json_decode($response->getBody(), true);
  93.                 if ($statusCode != 200) {
  94.                     return $this->createErrorResponse($statusCode);
  95.                 }
  97.                 $parsedData = array();
  98.                 if (isset($data['data']) && $format == "json") {
  99.                     foreach ($data['data'] as $item) {
  100.                         $parameter = $item["parameter"];
  101.                         $coordinates = $item["coordinates"];
  102.                         $lat = $coordinates[0]["lat"];
  103.                         $lon = $coordinates[0]["lon"];
  104.                         $dates = $coordinates[0]["dates"];
  105.                         $groupedDates = array();
  106.                         foreach ($dates as $date) {
  107.                             $dateTime = new DateTime($date["date"]);
  108.                             $dateString = $dateTime->format("Y-m-d");
  109.                             if (!array_key_exists($dateString, $groupedDates)) {
  110.                                 $groupedDates[$dateString] = array();
  111.                             }
  112.                             $groupedDates[$dateString][] = $date["value"];
  113.                         }
  114.                         $parsedData[$parameter] = array("coordinates" => array("lat" => $lat, "lon" => $lon), "dates" => $groupedDates);
  115.                     }
  116.                 } else {
  117.                     $parsedData = $data;
  118.                 }
  120.                 if ($parsedData) {
  121.                     $this->redisCache->set($redisKey, $parsedData, 86400);
  122.                 }
  123.             } else {
  124.                 $parsedData = $data;
  125.             }
  127.             return $parsedData;
  128.         } catch (Exception\RequestException $e) {
  129.             return throw new \Exception($e->getMessage());
  130.         } catch (\Exception $e) {
  131.             return throw new \Exception($e->getMessage());
  132.         }
  133.     }
  135.     public function createErrorResponse(int $http_code): Response
  136.     {
  137.         switch ($http_code) {
  138.             case 100:
  139.                 $text = 'Continue';
  140.                 break;
  141.             case 101:
  142.                 $text = 'Switching Protocols';
  143.                 break;
  144.             case 200:
  145.                 $text = 'OK';
  146.                 break;
  147.             case 201:
  148.                 $text = 'Created';
  149.                 break;
  150.             case 202:
  151.                 $text = 'Accepted';
  152.                 break;
  153.             case 203:
  154.                 $text = 'Non-Authoritative Information';
  155.                 break;
  156.             case 204:
  157.                 $text = 'No Content';
  158.                 break;
  159.             case 205:
  160.                 $text = 'Reset Content';
  161.                 break;
  162.             case 206:
  163.                 $text = 'Partial Content';
  164.                 break;
  165.             case 300:
  166.                 $text = 'Multiple Choices';
  167.                 break;
  168.             case 301:
  169.                 $text = 'Moved Permanently';
  170.                 break;
  171.             case 302:
  172.                 $text = 'Moved Temporarily';
  173.                 break;
  174.             case 303:
  175.                 $text = 'See Other';
  176.                 break;
  177.             case 304:
  178.                 $text = 'Not Modified';
  179.                 break;
  180.             case 305:
  181.                 $text = 'Use Proxy';
  182.                 break;
  183.             case 400:
  184.                 $text = 'Bad Request';
  185.                 break;
  186.             case 401:
  187.                 $text = 'Unauthorized';
  188.                 break;
  189.             case 402:
  190.                 $text = 'Payment Required';
  191.                 break;
  192.             case 403:
  193.                 $text = 'Forbidden';
  194.                 break;
  195.             case 404:
  196.                 $text = 'Not Found';
  197.                 break;
  198.             case 405:
  199.                 $text = 'Method Not Allowed';
  200.                 break;
  201.             case 406:
  202.                 $text = 'Not Acceptable';
  203.                 break;
  204.             case 407:
  205.                 $text = 'Proxy Authentication Required';
  206.                 break;
  207.             case 408:
  208.                 $text = 'Request Time-out';
  209.                 break;
  210.             case 409:
  211.                 $text = 'Conflict';
  212.                 break;
  213.             case 410:
  214.                 $text = 'Gone';
  215.                 break;
  216.             case 411:
  217.                 $text = 'Length Required';
  218.                 break;
  219.             case 412:
  220.                 $text = 'Precondition Failed';
  221.                 break;
  222.             case 413:
  223.                 $text = 'Request Entities Too Large';
  224.                 break;
  225.             case 414:
  226.                 $text = 'Request-URI Too Large';
  227.                 break;
  228.             case 415:
  229.                 $text = 'Unsupported Media Type';
  230.                 break;
  231.             case 500:
  232.                 $text = 'Internal Server Error';
  233.                 break;
  234.             case 501:
  235.                 $text = 'Not Implemented';
  236.                 break;
  237.             case 502:
  238.                 $text = 'Bad Gateway';
  239.                 break;
  240.             case 503:
  241.                 $text = 'Service Unavailable';
  242.                 break;
  243.             case 504:
  244.                 $text = 'Gateway Time-out';
  245.                 break;
  246.             case 505:
  247.                 $text = 'HTTP Version not supported';
  248.                 break;
  249.             default:
  250.                 $text = 'Unknown http status code';
  251.                 break;
  252.         }
  254.         $response = new Response();
  255.         $response->setContent($text);
  256.         $response->setStatusCode($http_code);
  257.         $response->headers->set('Content-Type', 'text/plain');
  259.         return $response;
  260.     }
  262.     /**
  263.      * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  264.      *
  265.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  266.      * @param int $days The number of days for which forecast is required
  267.      * @return array|null The weather forecast data in JSON format, or null if there was an error
  268.      */
  269.     public function getTempratureByParams(array $coordinates, string $startDate, string $endDate, string $parametersStr, int $hour = 1)
  270.     {
  271.         try {
  273.             if (count($coordinates) > 1) {
  275.                 // Validate the input parameters
  276.                 foreach ($coordinates as $coordinate) {
  277.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  278.                         throw new \InvalidArgumentException('Invalid coordinates');
  279.                     }
  280.                 }
  283.                 if (empty($startDate) || empty($endDate)) {
  284.                     throw new \InvalidArgumentException('Invalid dates');
  285.                 }
  287.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  288.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  290.                 // Create a Redis key for the cache
  291.                 $cacheKey = sprintf('custom_noti_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  292.                     return implode('_', $coordinate);
  293.                 }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr . $hour);
  295.                 // Try to get the data from Redis cache
  296.                 $cachedData = $this->redisCache->get($cacheKey);
  299.                 if ($cachedData !== null) {
  300.                     // Return the cached data if available
  301.                     return $cachedData;
  302.                 }
  305.                 // If cache is empty, get the data from the API
  306.                 $client = new Client(['verify' => false]);
  309.                 // $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  311.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  312.                 //   p_r($coordinateString); // Debug
  314.                 $url = sprintf(
  315.                     '%s/%s--%s:PT%sH/%s/%s/json?use_decluttered=true',
  316.                     $this->apiBaseUrl,
  317.                     $startDate,
  318.                     $endDate,
  319.                     $hour,
  320.                     $parametersStr,
  321.                     $coordinateString
  322.                 );
  323.             } else {
  325.                 //p_R($coordinates);
  326.                 if ($coordinates) {
  327.                     $latitude = $coordinates[0][0];
  328.                     $longitude = $coordinates[0][1];
  329.                 }
  331.                 // Validate the input parameters
  332.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  333.                     throw new \InvalidArgumentException('Invalid latitude');
  334.                 }
  335.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  336.                     throw new \InvalidArgumentException('Invalid longitude');
  337.                 }
  339.                 if (empty($startDate) || empty($endDate)) {
  340.                     throw new \InvalidArgumentException('Invalid dates');
  341.                 }
  343.                 // // $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  344.                 // // $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  346.                 // Create a Redis key for the cache            
  347.                 $cacheKey = sprintf('custom_noti_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  348.                     return implode('_', $coordinate);
  349.                 }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr . $hour);
  352.                 // Try to get the data from Redis cache
  353.                 $cachedData = $this->redisCache->get($cacheKey);
  355.                 if ($cachedData !== null) {
  356.                     // Return the cached data if available
  357.                     //return $cachedData;
  358.                 }
  359.                 
  360.                 // If cache is empty, get the data from the API
  361.                 $client = new Client(['verify' => false]);
  362.                 $url = sprintf(
  363.                     '%s/%s--%s:PT%sH/%s/%s,%s/json?use_decluttered=true',
  364.                     $this->apiBaseUrl,
  365.                     $startDate,
  366.                     $endDate,
  367.                     $hour,
  368.                     $parametersStr,
  369.                     $latitude,
  370.                     $longitude
  371.                 );
  373.                 //p_r($url);
  374.             }
  376.             $response = $client->request('GET', $url, [
  377.                 'auth' => [$this->username, $this->password],
  378.             ]);
  380.             $statusCode = $response->getStatusCode();
  381.             $data = json_decode($response->getBody(), true);
  383.             // Set the data to Redis cache
  384.             $this->redisCache->set($cacheKey, $data);
  386.             return $data;
  387.         } catch (GuzzleHttp\Exception\RequestException $e) {
  388.             return throw new \Exception($e->getMessage());
  389.         } catch (\Exception $e) {
  390.             return throw new \Exception($e->getMessage());
  391.         }
  392.     }
  395.     /**
  396.      * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  397.      *
  398.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  399.      * @param int $days The number of days for which forecast is required
  400.      * @return array|null The weather forecast data in JSON format, or null if there was an error
  401.      */
  402.     public function getForecastData(array $coordinates, string $startDate, string $endDate, int $hours, string $model = "ksancm-wrf-48", $translator)
  403.     {
  404.         try {
  406.             // Set timezone to Saudi (UTC+3)
  407.             $timezone = new \DateTimeZone('Asia/Riyadh');
  408.             if (count($coordinates) > 1) {
  409.                 // Validate the input parameters
  410.                 foreach ($coordinates as $coordinate) {
  411.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  412.                         // throw new \InvalidArgumentException('Invalid coordinates');
  413.                         return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  414.                     }
  415.                 }
  416.                 if (empty($startDate) || empty($endDate)) {
  417.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  418.                     // throw new \InvalidArgumentException('Invalid dates');
  419.                 }
  420.                 if ($hours < 1 and $hours > 24) {
  421.                     throw new \InvalidArgumentException('Invalid hour');
  422.                 }
  423.                 // $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  424.                 // $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  426.                 // // Adjust the date range based on the hours parameter
  427.                 // if ($hours == 24) {
  428.                 //     $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  429.                 //    $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  430.                 // } elseif ($hours == 1) {
  431.                 //    $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  432.                 //    $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  433.                 // }
  435.                 // Convert dates to Saudi timezone
  436.                 $startDateObj = new \DateTime($startDate, $timezone);
  437.                 $endDateObj = new \DateTime($endDate, $timezone);
  438.                 // Subtract 3 hours from each date
  439.                 // $startDateObj->modify('-3 hours');
  440.                 // $endDateObj->modify('-3 hours');
  441.                 $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  442.                 $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  444.                 // Adjust date range based on the hours parameter
  445.                 $startDateNew = clone $startDateObj;
  446.                 $endDateNew = clone $endDateObj;
  448.                 if ($hours == 24) {
  449.                     $startDateNew->modify('+1 day');
  450.                     $endDateNew->modify('+1 day');
  451.                 } elseif ($hours == 1) {
  452.                     $startDateNew->modify('+1 hour');
  453.                     $endDateNew->modify('+1 hour');
  454.                 }
  457.                 $startDateNew = $startDateNew->format('Y-m-d\TH:i:s.v\Z');
  458.                 $endDateNew = $endDateNew->format('Y-m-d\TH:i:s.v\Z');
  460.                 // Create a Redis key for the cache
  461.                 $cacheKey = sprintf('daily_forecast_%s_%s', implode('_', array_map(function ($coordinate) {
  462.                     return implode('_', $coordinate);
  463.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model . $hours);
  464.                 // Try to get the data from Redis cache
  465.                 $cachedData = $this->redisCache->get($cacheKey);
  466.                 if ($cachedData !== null) {
  467.                     // Return the cached data if available
  468.                     return $cachedData;
  469.                 }
  470.                 // If cache is empty, get the data from the API
  471.                 $client = new Client(['verify' => false]);
  473.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  474.                 $url1 = sprintf(
  475.                     '%s/%s--%s:PT%sH/t_max_2m_%sh:C,t_min_2m_%sh:C,t_apparent_min_%sh:C,t_apparent_max_%sh:C/%s/json?model=' . $model . '&use_decluttered=true',
  476.                     $this->apiBaseUrl,
  477.                     $startDateNew,
  478.                     $endDateNew,
  479.                     $hours,
  480.                     $hours,
  481.                     $hours,
  482.                     $hours,
  483.                     $hours,
  484.                     $coordinateString
  485.                 );
  486.                 $url2 = sprintf(
  487.                     '%s/%s--%s:PT%sH/wind_speed_mean_10m_%sh:kmh,wind_dir_mean_10m_%sh:d,prob_precip_%sh:p,precip_%sh:mm,relative_humidity_mean_2m_%sh:p,effective_cloud_cover_mean_%sh:octas,dew_point_mean_2m_%sh:C,wind_gusts_10m_%sh:kmh/%s/json?model=' . $model . '&use_decluttered=true',
  488.                     $this->apiBaseUrl,
  489.                     $startDateNew,
  490.                     $endDateNew,
  491.                     $hours,
  492.                     $hours,
  493.                     $hours,
  494.                     $hours,
  495.                     $hours,
  496.                     $hours,
  497.                     $hours,
  498.                     $hours,
  499.                     $hours,
  500.                     $coordinateString
  501.                 );
  502.                 $url3 = sprintf(
  503.                     '%s/%s--%s:PT%sH/t_2m:C,visibility:km,wind_gusts_10m_%sh:kn,wind_speed_mean_10m_%sh:kn/%s/json?model=mix&use_decluttered=true',
  504.                     $this->apiBaseUrl,
  505.                     $startDateNew,
  506.                     $endDateNew,
  507.                     $hours,
  508.                     $hours,
  509.                     $hours,
  510.                     $coordinateString
  511.                 );
  512.                 $url4 = sprintf(
  513.                     '%s/%s--%s:PT10M/t_2m:C/%s/json?model=' . $model . '&use_decluttered=true',
  514.                     $this->apiBaseUrl,
  515.                     $startDateNew,
  516.                     $endDateNew,
  517.                     $coordinateString
  518.                 );
  519.                 $url5 = sprintf(
  520.                     '%s/%s--%s:PT3H/precip_3h:mm,prob_precip_3h:p/%s/json?model=' . $model . '&use_decluttered=true',
  521.                     $this->apiBaseUrl,
  522.                     $startDateNew,
  523.                     $endDateNew,
  524.                     $coordinateString
  525.                 );
  526.                 $url6 = sprintf(
  527.                     '%s/%s--%s:PT6H/precip_6h:mm,prob_precip_6h:p,wind_speed_mean_100m_%sh:kmh,wind_speed_mean_200m_%sh:kmh,wind_speed_mean_300m_%sh:kmh/%s/json?model=' . $model . '&use_decluttered=true',
  528.                     $this->apiBaseUrl,
  529.                     $startDateNew,
  530.                     $endDateNew,
  531.                     $hours,
  532.                     $hours,
  533.                     $hours,
  534.                     $coordinateString
  535.                 );
  536.             } else {
  537.                 if ($coordinates) {
  538.                     $latitude = $coordinates[0][0];
  539.                     $longitude = $coordinates[0][1];
  540.                 }
  541.                 // Validate the input parameters
  542.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  543.                     // throw new \InvalidArgumentException('Invalid latitude');
  544.                     return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  545.                 }
  546.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  547.                     // throw new \InvalidArgumentException('Invalid longitude');
  548.                     return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  549.                 }
  550.                 if (empty($startDate) || empty($endDate)) {
  551.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  552.                 }
  553.                 if ($hours < 1 and $hours > 24) {
  554.                     throw new \InvalidArgumentException('Invalid hour');
  555.                 }
  556.                 // $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  557.                 // $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  559.                 // // Adjust the date range based on the hours parameter
  560.                 // if ($hours == 24) {
  561.                 //     $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  562.                 //     $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  563.                 //  } elseif ($hours == 1) {
  564.                 //     $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  565.                 //     $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  566.                 // }
  568.                 // Convert dates to Saudi timezone
  569.                 $startDateObj = new \DateTime($startDate, $timezone);
  570.                 $endDateObj = new \DateTime($endDate, $timezone);
  571.                 // Subtract 3 hours from each date
  572.                 // $startDateObj->modify('-3 hours');
  573.                 // $endDateObj->modify('-3 hours');
  574.                 $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  575.                 $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  577.                 // Adjust date range based on the hours parameter
  578.                 $startDateNew = clone $startDateObj;
  579.                 $endDateNew = clone $endDateObj;
  581.                 if ($hours == 24) {
  582.                     $startDateNew->modify('+1 day');
  583.                     $endDateNew->modify('+1 day');
  584.                 } elseif ($hours == 1) {
  585.                     $startDateNew->modify('+1 hour');
  586.                     $endDateNew->modify('+1 hour');
  587.                 }
  590.                 $startDateNew = $startDateNew->format('Y-m-d\TH:i:s.v\Z');
  591.                 $endDateNew = $endDateNew->format('Y-m-d\TH:i:s.v\Z');
  592.                 // Create a Redis key for the cache            
  593.                 $cacheKey = sprintf('daily_forecast_%s_%s', implode('_', array_map(function ($coordinate) {
  594.                     return implode('_', $coordinate);
  595.                 }, $coordinates)), ($startDate . '-' . $endDate) . $model . $hours);
  596.                 // Try to get the data from Redis cache
  597.                 $cachedData = $this->redisCache->get($cacheKey);
  598.                 if ($cachedData !== null) {
  599.                     // Return the cached data if available
  600.                     return $cachedData;
  601.                 }
  602.                 // If cache is empty, get the data from the API
  603.                 $client = new Client(['verify' => false]);
  604.                 $url1 = sprintf(
  605.                     '%s/%s--%s:PT%sH/t_max_2m_%sh:C,t_min_2m_%sh:C,t_apparent_min_%sh:C,t_apparent_max_%sh:C/%s,%s/json?model=' . $model . '&use_decluttered=true',
  606.                     $this->apiBaseUrl,
  607.                     $startDateNew,
  608.                     $endDateNew,
  609.                     $hours,
  610.                     $hours,
  611.                     $hours,
  612.                     $hours,
  613.                     $hours,
  614.                     $latitude,
  615.                     $longitude
  616.                 );
  617.                 // print_r($url1);exit;
  618.                 $url2 = sprintf(
  619.                     '%s/%s--%s:PT%sH/wind_speed_mean_10m_%sh:kmh,wind_dir_mean_10m_%sh:d,prob_precip_%sh:p,precip_%sh:mm,relative_humidity_mean_2m_%sh:p,effective_cloud_cover_mean_%sh:octas,dew_point_mean_2m_%sh:C,wind_gusts_10m_%sh:kmh/%s,%s/json?model=' . $model . '&use_decluttered=true',
  620.                     $this->apiBaseUrl,
  621.                     $startDateNew,
  622.                     $endDateNew,
  623.                     $hours,
  624.                     $hours,
  625.                     $hours,
  626.                     $hours,
  627.                     $hours,
  628.                     $hours,
  629.                     $hours,
  630.                     $hours,
  631.                     $hours,
  632.                     $latitude,
  633.                     $longitude
  634.                 );
  635.                 $url3 = sprintf(
  636.                     '%s/%s--%s:PT%sH/t_2m:C,visibility:km,wind_gusts_10m_%sh:kn,wind_speed_mean_10m_%sh:kn/%s,%s/json?model=mix&use_decluttered=true',
  637.                     $this->apiBaseUrl,
  638.                     $startDateNew,
  639.                     $endDateNew,
  640.                     $hours,
  641.                     $hours,
  642.                     $hours,
  643.                     $latitude,
  644.                     $longitude
  645.                 );
  646.                 $url4 = sprintf(
  647.                     '%s/%s--%s:PT10M/t_2m:C/%s,%s/json?model=' . $model . '&use_decluttered=true',
  648.                     $this->apiBaseUrl,
  649.                     $startDateNew,
  650.                     $endDateNew,
  651.                     $latitude,
  652.                     $longitude
  653.                 );
  654.                 $url5 = sprintf(
  655.                     '%s/%s--%s:PT3H/precip_3h:mm,prob_precip_3h:p/%s,%s/json?model=' . $model . '&use_decluttered=true',
  656.                     $this->apiBaseUrl,
  657.                     $startDateNew,
  658.                     $endDateNew,
  659.                     $latitude,
  660.                     $longitude
  661.                 );
  662.                 $url6 = sprintf(
  663.                     '%s/%s--%s:PT6H/precip_6h:mm,prob_precip_6h:p,wind_speed_mean_100m_%sh:kmh,wind_speed_mean_200m_%sh:kmh,wind_speed_mean_300m_%sh:kmh/%s,%s/json?model=' . $model . '&use_decluttered=true',
  664.                     $this->apiBaseUrl,
  665.                     $startDateNew,
  666.                     $endDateNew,
  667.                     $hours,
  668.                     $hours,
  669.                     $hours,
  670.                     $latitude,
  671.                     $longitude
  672.                 );
  673.             }
  674.             $response = $client->request('GET', $url1, [
  675.                 'auth' => [$this->username, $this->password],
  676.             ]);
  677.             $statusCode = $response->getStatusCode();
  678.             $data1 = json_decode($response->getBody(), true);
  679.             // Adjust the dates in the response data
  680.             $this->adjustResponseDates($data1['data'], $hours);
  682.             $response = $client->request('GET', $url2, [
  683.                 'auth' => [$this->username, $this->password],
  684.             ]);
  685.             $statusCode = $response->getStatusCode();
  686.             $data2 = json_decode($response->getBody(), true);
  687.             $this->adjustResponseDates($data2['data'], $hours);
  689.             $response = $client->request('GET', $url3, [
  690.                 'auth' => [$this->username, $this->password],
  691.             ]);
  692.             $statusCode = $response->getStatusCode();
  693.             $data3 = json_decode($response->getBody(), true);
  694.             $this->adjustResponseDates($data3['data'], $hours);
  696.             $response = $client->request('GET', $url4, [
  697.                 'auth' => [$this->username, $this->password],
  698.             ]);
  699.             $statusCode = $response->getStatusCode();
  700.             $data4 = json_decode($response->getBody(), true);
  701.             $this->adjustResponseDates($data4['data'], $hours);
  703.             $response = $client->request('GET', $url5, [
  704.                 'auth' => [$this->username, $this->password],
  705.             ]);
  706.             $statusCode = $response->getStatusCode();
  707.             $data5 = json_decode($response->getBody(), true);
  708.             $this->adjustResponseDates($data5['data'], $hours);
  710.             $response = $client->request('GET', $url6, [
  711.                 'auth' => [$this->username, $this->password],
  712.             ]);
  713.             $statusCode = $response->getStatusCode();
  714.             $data6 = json_decode($response->getBody(), true);
  715.             $this->adjustResponseDates($data6['data'], $hours);
  717.             $dataFinal = $data1;
  718.             $dataFinal['data'] = array_merge($data6['data'], $data5['data'], $data4['data'], $data1['data'], $data2['data'], $data3['data']);
  719.             $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT' . $hours . 'H', $hours . 'h', true);
  720.             if (isset($weatherSymbols['data'][0]['parameter'])) {
  721.                 $dataFinal['symbols'] = $weatherSymbols['data'][0];
  722.             }
  723.             // Set the data to Redis cache
  724.             $this->redisCache->set($cacheKey, $dataFinal);
  725.             return $dataFinal;
  726.         } catch (GuzzleHttp\Exception\RequestException $e) {
  727.             return throw new \Exception($e->getMessage());
  728.         } catch (\Exception $e) {
  729.             return throw new \Exception($e->getMessage());
  730.         }
  731.     }
  734.     /**
  735.      * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  736.      *
  737.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  738.      * @param string $hourly The hour for which forecast is required in 24-hour format
  739.      * @return array The hourly weather forecast data in JSON format
  740.      */
  741.     public function getHourlyForecastData(array $coordinates, string $startDate, string $endDate, int $hour, string $model, $translator)
  742.     {
  743.         try {
  744.             if (count($coordinates) > 1) {
  746.                 // Validate the input parameters
  747.                 foreach ($coordinates as $coordinate) {
  748.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  749.                         return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  750.                     }
  751.                 }
  753.                 if (empty($startDate) || empty($endDate)) {
  754.                     // throw new \InvalidArgumentException('Invalid dates');
  755.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  756.                 }
  758.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  759.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  761.                 // Create a Redis key for the cache
  762.                 $cacheKey = sprintf('hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  763.                     return implode('_', $coordinate);
  764.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, $hour);
  767.                 // Try to get the data from Redis cache
  768.                 $cachedData = $this->redisCache->get($cacheKey);
  771.                 if ($cachedData !== null) {
  772.                     // Return the cached data if available
  773.                     return $cachedData;
  774.                 }
  777.                 // If cache is empty, get the data from the API
  778.                 $client = new Client(['verify' => false]);
  780.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  781.                 $url1 = sprintf(
  782.                     '%s/%s--%s:PT%sH/t_max_2m_1h:C,t_min_2m_1h:C,t_apparent_min_1h:C,t_apparent_max_1h:C,wind_speed_mean_10m_1h:kn,wind_gusts_10m_1h:kn/%+%/json?model=' . $model . '&use_decluttered=true',
  783.                     $this->apiBaseUrl,
  784.                     $startDate,
  785.                     $endDate,
  786.                     $hour,
  787.                     $coordinateString,
  788.                     $coordinateString
  789.                 );
  790.                 $url2 = sprintf(
  791.                     '%s/%s--%s:PT%sH/wind_speed_mean_10m_1h:kmh,wind_dir_mean_10m_1h:d,prob_precip_1h:p,precip_1h:mm,relative_humidity_mean_2m_1h:p,visibility:km,effective_cloud_cover_mean_1h:octas,dew_point_mean_2m_1h:C,wind_gusts_10m_1h:kmh/%+%/json?model=' . $model . '&use_decluttered=true',
  792.                     $this->apiBaseUrl,
  793.                     $startDate,
  794.                     $endDate,
  795.                     $hour,
  796.                     $coordinateString,
  797.                     $coordinateString
  798.                 );
  799.             } else {
  801.                 if ($coordinates) {
  802.                     $latitude = $coordinates[0][0];
  803.                     $longitude = $coordinates[0][1];
  804.                 }
  806.                 // Validate the input parameters
  807.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  808.                     // throw new \InvalidArgumentException('Invalid latitude');
  809.                     return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  810.                 }
  811.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  812.                     // throw new \InvalidArgumentException('Invalid longitude');
  813.                     return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  814.                 }
  816.                 if (empty($startDate) || empty($endDate)) {
  817.                     // throw new \InvalidArgumentException('Invalid dates');
  818.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  819.                 }
  821.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  822.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  824.                 // Create a Redis key for the cache            
  825.                 $cacheKey = sprintf('hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  826.                     return implode('_', $coordinate);
  827.                 }, $coordinates)), ($startDate . '-' . $endDate) . $model, $hour);
  829.                 // Try to get the data from Redis cache
  830.                 $cachedData = $this->redisCache->get($cacheKey);
  832.                 if ($cachedData !== null) {
  833.                     // Return the cached data if available
  834.                     return $cachedData;
  835.                 }
  837.                 // If cache is empty, get the data from the API
  838.                 $client = new Client(['verify' => false]);
  839.                 $url1 = sprintf(
  840.                     '%s/%s--%s:PT%sH/t_max_2m_1h:C,t_min_2m_1h:C,t_apparent_min_1h:C,t_apparent_max_1h:C,wind_speed_mean_10m_1h:kn,wind_gusts_10m_1h:kn/%s,%s/json?model=' . $model . '&use_decluttered=true',
  841.                     $this->apiBaseUrl,
  842.                     $startDate,
  843.                     $endDate,
  844.                     $hour,
  845.                     $latitude,
  846.                     $longitude
  847.                 );
  848.                 $url2 = sprintf(
  849.                     '%s/%s--%s:PT%sH/wind_speed_mean_10m_1h:kmh,wind_dir_mean_10m_1h:d,prob_precip_1h:p,precip_1h:mm,relative_humidity_mean_2m_1h:p,visibility:km,effective_cloud_cover_mean_1h:octas,dew_point_mean_2m_1h:C,wind_gusts_10m_1h:kmh/%s,%s/json?model=' . $model . '&use_decluttered=true',
  850.                     $this->apiBaseUrl,
  851.                     $startDate,
  852.                     $endDate,
  853.                     $hour,
  854.                     $latitude,
  855.                     $longitude
  856.                 );
  857.             }
  859.             $response = $client->request('GET', $url1, [
  860.                 'auth' => [$this->username, $this->password],
  861.             ]);
  863.             $statusCode = $response->getStatusCode();
  864.             $data1 = json_decode($response->getBody(), true);
  866.             $response = $client->request('GET', $url2, [
  867.                 'auth' => [$this->username, $this->password],
  868.             ]);
  870.             $statusCode = $response->getStatusCode();
  871.             $data2 = json_decode($response->getBody(), true);
  873.             $data3 = $data1;
  874.             $data3['data'] = array_merge($data1['data'], $data2['data']);
  876.             $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT1H', '1h');
  878.             if (isset($weatherSymbols['data'][0]['parameter'])) {
  879.                 $data3['symbols'] = $weatherSymbols['data'][0];
  880.             }
  882.             // Set the data to Redis cache
  883.             $this->redisCache->set($cacheKey, $data3);
  885.             return $data3;
  886.         } catch (GuzzleHttp\Exception\RequestException $e) {
  887.             return throw new \Exception($e->getMessage());
  888.         } catch (\Exception $e) {
  889.             return throw new \Exception($e->getMessage());
  890.         }
  891.     }
  894.     /**
  895.      * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  896.      *
  897.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  898.      * @param string $hourly The hour for which forecast is required in 24-hour format
  899.      * @return array The hourly weather forecast data in JSON format
  900.      */
  901.     public function getForecastDataHistoryHourly(array $coordinates, string $startDate, string $endDate, $translator, int $hour = 1)
  902.     {
  903.         try {
  904.             if (count($coordinates) > 1) {
  906.                 // Validate the input parameters
  907.                 foreach ($coordinates as $coordinate) {
  908.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  909.                         // throw new \InvalidArgumentException('Invalid coordinates');
  910.                         return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  911.                     }
  912.                 }
  915.                 if (empty($startDate) || empty($endDate)) {
  916.                     // throw new \InvalidArgumentException('Invalid dates');
  917.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  918.                 }
  920.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  921.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  923.                 // Create a Redis key for the cache
  924.                 $cacheKey = sprintf('historical_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  925.                     return implode('_', $coordinate);
  926.                 }, $coordinates)), (($startDate) . '-' . ($endDate)), $hour);
  928.                 // Try to get the data from Redis cache
  929.                 $cachedData = $this->redisCache->get($cacheKey);
  932.                 if ($cachedData !== null) {
  933.                     // Return the cached data if available
  934.                     return $cachedData;
  935.                 }
  938.                 // If cache is empty, get the data from the API
  939.                 $client = new Client(['verify' => false]);
  941.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  942.                 $url1 = sprintf(
  943.                     '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm/%s+%s/json?use_decluttered=true',
  944.                     $this->apiBaseUrl,
  945.                     $startDate,
  946.                     $endDate,
  947.                     $hour,
  948.                     $coordinateString,
  949.                     $coordinateString
  950.                 );
  951.                 $url2 = sprintf(
  952.                     '%s/%s--%s:PT%sH/effective_cloud_cover:octas,dew_point_2m:C,wind_speed_mean_10m_1h:ms,wind_speed_10m:kn/%s+%s/json?use_decluttered=true',
  953.                     $this->apiBaseUrl,
  954.                     $startDate,
  955.                     $endDate,
  956.                     $hour,
  957.                     $coordinateString,
  958.                     $coordinateString
  959.                 );
  960.             } else {
  962.                 if ($coordinates) {
  963.                     $latitude = $coordinates[0][0];
  964.                     $longitude = $coordinates[0][1];
  965.                 }
  967.                 // Validate the input parameters
  968.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  969.                     // throw new \InvalidArgumentException('Invalid latitude');
  970.                     return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  971.                 }
  972.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  973.                     // throw new \InvalidArgumentException('Invalid longitude');
  974.                     return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  975.                 }
  977.                 if (empty($startDate) || empty($endDate)) {
  978.                     // throw new \InvalidArgumentException('Invalid dates');
  979.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  980.                 }
  982.                 // 2023-04-06T00:00:00.000Z--2023-04-07T00:00:00.000Z
  983.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  984.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  986.                 // Create a Redis key for the cache            
  987.                 $cacheKey = sprintf('historical_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  988.                     return implode('_', $coordinate);
  989.                 }, $coordinates)), (($startDate) . '-' . ($endDate)), $hour);
  992.                 // Try to get the data from Redis cache
  993.                 $cachedData = $this->redisCache->get($cacheKey);
  995.                 if ($cachedData !== null) {
  996.                     // Return the cached data if available
  997.                     return $cachedData;
  998.                 }
  1000.                 // If cache is empty, get the data from the API
  1001.                 $client = new Client(['verify' => false]);
  1002.                 $url1 = sprintf(
  1003.                     '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm/%s,%s/json?use_decluttered=true',
  1004.                     $this->apiBaseUrl,
  1005.                     $startDate,
  1006.                     $endDate,
  1007.                     $hour,
  1008.                     $latitude,
  1009.                     $longitude
  1010.                 );
  1012.                 $url2 = sprintf(
  1013.                     '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm,wind_speed_10m:kn/%s,%s/json?use_decluttered=true',
  1014.                     $this->apiBaseUrl,
  1015.                     $startDate,
  1016.                     $endDate,
  1017.                     $hour,
  1018.                     $latitude,
  1019.                     $longitude
  1020.                 );
  1022.                 //echo $url;exit;
  1024.             }
  1025.             $response = $client->request('GET', $url1, [
  1026.                 'auth' => [$this->username, $this->password],
  1027.             ]);
  1029.             $statusCode = $response->getStatusCode();
  1030.             $data1 = json_decode($response->getBody(), true);
  1032.             $response = $client->request('GET', $url2, [
  1033.                 'auth' => [$this->username, $this->password],
  1034.             ]);
  1036.             $statusCode = $response->getStatusCode();
  1037.             $data2 = json_decode($response->getBody(), true);
  1039.             array_push($data1['data'], $data2['data']);
  1041.             $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT1H', $hour . 'h');
  1043.             if (isset($weatherSymbols['data'][0]['parameter'])) {
  1044.                 $data1['symbols'] = $weatherSymbols['data'][0];
  1045.             }
  1047.             // Set the data to Redis cache
  1048.             $this->redisCache->set($cacheKey, $data1);
  1050.             return $data1;
  1051.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1053.             //p_r($e->getMessage());exit;
  1054.             return throw new \Exception($e->getMessage());
  1055.         } catch (\Exception $e) {
  1056.             //p_r($e->getMessage());exit;
  1057.             return throw new \Exception($e->getMessage());
  1058.         }
  1059.     }
  1062.     /**
  1063.      * Compare weather based on mateomatics models
  1064.      *
  1065.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1066.      * @param string $hourly The hour for which forecast is required in 24-hour format
  1067.      * @return array The hourly weather forecast data in JSON format
  1068.      */
  1069.     public function getCompareParameters(array $coordinates, string $startDate, string $endDate, string $model, string $tempParam, string $timeDuration = "P1H", $translator)
  1070.     {
  1071.         try {
  1073.             if (count($coordinates) > 1) {
  1075.                 // Validate the input parameters
  1076.                 foreach ($coordinates as $coordinate) {
  1077.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1078.                         // throw new \InvalidArgumentException('Invalid coordinates');
  1079.                         return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1080.                     }
  1081.                 }
  1084.                 if (empty($startDate) || empty($endDate)) {
  1085.                     // throw new \InvalidArgumentException('Invalid dates');
  1086.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1087.                 }
  1089.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1090.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1092.                 // Create a Redis key for the cache
  1093.                 $cacheKey = sprintf('compare_model_%s_%s_' . $model . '_' . $tempParam, implode('_', array_map(function ($coordinate) {
  1094.                     return implode('_', $coordinate);
  1095.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $timeDuration);
  1097.                 // Try to get the data from Redis cache
  1098.                 $cachedData = $this->redisCache->get($cacheKey);
  1101.                 if ($cachedData !== null) {
  1102.                     // Return the cached data if available
  1103.                     return $cachedData;
  1104.                 }
  1107.                 // If cache is empty, get the data from the API
  1108.                 $client = new Client(['verify' => false]);
  1111.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1112.                 $url = sprintf(
  1113.                     '%s/%s--%s:%s/%s/%+%/json?model=' . $model . '&use_decluttered=true',
  1114.                     $this->apiBaseUrl,
  1115.                     $startDate,
  1116.                     $endDate,
  1117.                     $timeDuration,
  1118.                     $tempParam,
  1119.                     $coordinateString,
  1120.                     $coordinateString
  1121.                 );
  1122.             } else {
  1124.                 if ($coordinates) {
  1125.                     $latitude = $coordinates[0][0];
  1126.                     $longitude = $coordinates[0][1];
  1127.                 }
  1129.                 // Validate the input parameters
  1130.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1131.                     // throw new \InvalidArgumentException('Invalid latitude');
  1132.                     return ["success" => true, "message" => $translator->trans("invalid_latitude")];
  1133.                 }
  1134.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1135.                     // throw new \InvalidArgumentException('Invalid longitude');
  1136.                     return ["success" => true, "message" => $translator->trans("invalid_longitude")];
  1137.                 }
  1139.                 if (empty($startDate) || empty($endDate)) {
  1140.                     // throw new \InvalidArgumentException('Invalid dates');
  1141.                     return ["success" => true, "message" => $translator->trans("invalid_dates")];
  1142.                 }
  1144.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1145.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1147.                 // Create a Redis key for the cache            
  1148.                 $cacheKey = sprintf('compare_model_%s_%s_' . $model . '_' . $tempParam, implode('_', array_map(function ($coordinate) {
  1149.                     return implode('_', $coordinate);
  1150.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $timeDuration);
  1153.                 // Try to get the data from Redis cache
  1154.                 $cachedData = $this->redisCache->get($cacheKey);
  1156.                 if ($cachedData !== null) {
  1157.                     // Return the cached data if available
  1158.                     return $cachedData;
  1159.                 }
  1161.                 // If cache is empty, get the data from the API
  1162.                 $client = new Client(['verify' => false]);
  1163.                 $url = sprintf(
  1164.                     '%s/%s--%s:%s/%s/%s,%s/json?model=' . $model . '&use_decluttered=true',
  1165.                     $this->apiBaseUrl,
  1166.                     $startDate,
  1167.                     $endDate,
  1168.                     $timeDuration,
  1169.                     $tempParam,
  1170.                     $latitude,
  1171.                     $longitude
  1172.                 );
  1173.             }
  1175.             $response = $client->request('GET', $url, [
  1176.                 'auth' => [$this->username, $this->password],
  1177.             ]);
  1179.             $statusCode = $response->getStatusCode();
  1180.             $data = json_decode($response->getBody(), true);
  1182.             // Set the data to Redis cache
  1183.             $this->redisCache->set($cacheKey, $data);
  1185.             return $data;
  1186.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1188.             return throw new \Exception($e->getMessage());
  1189.         } catch (\Exception $e) {
  1190.             return throw new \Exception($e->getMessage());
  1191.         }
  1192.     }
  1195.     /**
  1196.      * Get forecast data in daily dashboard display for multiple locations
  1197.      *
  1198.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1199.      * @param int $days The number of days for which forecast is required
  1200.      * @return array The model forecast data
  1201.      */
  1202.     public function getDashboardDailyForecast(array $coordinates, string $startDate, string $endDate)
  1203.     {
  1204.         try {
  1206.             if (count($coordinates) > 1) {
  1208.                 // Validate the input parameters
  1209.                 foreach ($coordinates as $coordinate) {
  1210.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1211.                         throw new \InvalidArgumentException('Invalid coordinates');
  1212.                     }
  1213.                 }
  1216.                 if (empty($startDate) || empty($endDate)) {
  1217.                     throw new \InvalidArgumentException('Invalid dates');
  1218.                 }
  1220.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1221.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1223.                 // Create a Redis key for the cache
  1224.                 $cacheKey = sprintf('dashboard_%s_%s', implode('_', array_map(function ($coordinate) {
  1225.                     return implode('_', $coordinate);
  1226.                 }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1228.                 // Try to get the data from Redis cache
  1229.                 $cachedData = $this->redisCache->get($cacheKey);
  1232.                 if ($cachedData !== null) {
  1233.                     // Return the cached data if available
  1234.                     return $cachedData;
  1235.                 }
  1238.                 // If cache is empty, get the data from the API
  1239.                 $client = new Client(['verify' => false]);
  1242.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1244.                 $url = sprintf(
  1245.                     '%s/%s--%s:P%sD/t_max_2m_24h:C,t_apparent:C,wind_speed_10m:kmh,wind_dir_mean_10m_24h:d,prob_precip_24h:p,precip_24h:mm,sunrise:sql,visibility:km,wind_speed_10m:kn/%+%/json?use_decluttered=true',
  1246.                     $this->apiBaseUrl,
  1247.                     $endDate,
  1248.                     $startDate,
  1249.                     1,
  1250.                     $coordinateString,
  1251.                     $coordinateString
  1252.                 );
  1253.             } else {
  1255.                 if ($coordinates) {
  1256.                     $latitude = $coordinates[0][0];
  1257.                     $longitude = $coordinates[0][1];
  1258.                 }
  1260.                 // Validate the input parameters
  1261.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1262.                     throw new \InvalidArgumentException('Invalid latitude');
  1263.                 }
  1264.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1265.                     throw new \InvalidArgumentException('Invalid longitude');
  1266.                 }
  1268.                 if (empty($startDate) || empty($endDate)) {
  1269.                     throw new \InvalidArgumentException('Invalid dates');
  1270.                 }
  1272.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1273.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1275.                 // Create a Redis key for the cache            
  1276.                 $cacheKey = sprintf('dashboard_%s_%s', implode('_', array_map(function ($coordinate) {
  1277.                     return implode('_', $coordinate);
  1278.                 }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1281.                 // Try to get the data from Redis cache
  1282.                 $cachedData = $this->redisCache->get($cacheKey);
  1284.                 if ($cachedData !== null) {
  1285.                     // Return the cached data if available
  1286.                     return $cachedData;
  1287.                 }
  1289.                 // If cache is empty, get the data from the API
  1290.                 $client = new Client(['verify' => false]);
  1291.                 $url = sprintf(
  1292.                     '%s/%s--%s:P%sD/t_max_2m_24h:C,t_apparent:C,wind_speed_10m:kmh,wind_dir_mean_10m_24h:d,prob_precip_24h:p,precip_24h:mm,sunrise:sql,visibility:km,wind_speed_10m:kn/%s,%s/json?use_decluttered=true',
  1293.                     $this->apiBaseUrl,
  1294.                     $endDate,
  1295.                     $startDate,
  1296.                     1,
  1297.                     $latitude,
  1298.                     $longitude
  1299.                 );
  1300.             }
  1302.             $response = $client->request('GET', $url, [
  1303.                 'auth' => [$this->username, $this->password],
  1304.             ]);
  1306.             $statusCode = $response->getStatusCode();
  1307.             $data = json_decode($response->getBody(), true);
  1309.             // Set the data to Redis cache
  1310.             $this->redisCache->set($cacheKey, $data);
  1312.             return $data;
  1313.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1314.             return throw new \Exception($e->getMessage());
  1315.         } catch (\Exception $e) {
  1316.             return throw new \Exception($e->getMessage());
  1317.         }
  1318.     }
  1321.     /**
  1322.      * Get forecast data for the provided coordinates
  1323.      *
  1324.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1325.      * @param string $timestamp The timestamp for which forecast is required in the format "YYYY-MM-DDTHHZ"
  1326.      * @param string $duration The duration for which forecast is required in ISO 8601 format "P1D" for 1 day, "PT1H" for 1 hour
  1327.      * @param string $parameters The weather parameters to fetch separated by comma, e.g. "t_2m:C,sfc_pressure:hPa,wind_speed_10m:ms"
  1328.      * @param string $aggregations The aggregations to apply to the fetched parameters separated by comma, e.g. "mean,sum"
  1329.      * @param string $format The format in which to receive the data, either "json" or "xml"
  1330.      *
  1331.      * @return array The forecast data for the provided coordinates
  1332.      */
  1333.     public function getForecastForCoordinates(
  1334.         array $coordinates,
  1335.         string $timestamp,
  1336.         string $duration,
  1337.         string $parameters,
  1338.         string $aggregations,
  1339.         string $format
  1340.     ) {
  1341.         try {
  1342.             // Validate the input parameters
  1343.             foreach ($coordinates as $coordinate) {
  1344.                 if (!is_array($coordinate) || count($coordinate) !== 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1345.                     throw new \InvalidArgumentException('Invalid coordinates');
  1346.                 }
  1347.             }
  1349.             if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}Z$/', $timestamp)) {
  1350.                 throw new \InvalidArgumentException('Invalid timestamp');
  1351.             }
  1353.             if (!in_array($duration, ['PT1H', 'P1D'])) {
  1354.                 throw new \InvalidArgumentException('Invalid duration');
  1355.             }
  1357.             if (!is_string($parameters) || empty($parameters)) {
  1358.                 throw new \InvalidArgumentException('Invalid parameters');
  1359.             }
  1361.             if (!is_string($aggregations) || empty($aggregations)) {
  1362.                 throw new \InvalidArgumentException('Invalid aggregations');
  1363.             }
  1365.             if (!in_array($format, ['json', 'xml'])) {
  1366.                 throw new \InvalidArgumentException('Invalid format');
  1367.             }
  1369.             // Convert the coordinates array into a string
  1370.             $coordinatesString = implode('_', array_map(function ($coordinate) {
  1371.                 return implode(',', $coordinate);
  1372.             }, $coordinates));
  1374.             // Build the URL for the API call
  1375.             $url = sprintf(
  1376.                 '%s/%s/%s/%s/%s/%s/%s.%s?use_decluttered=true',
  1377.                 $this->apiBaseUrl,
  1378.                 $timestamp,
  1379.                 $duration,
  1380.                 $parameters,
  1381.                 $coordinatesString,
  1382.                 $aggregations,
  1383.                 $format
  1384.             );
  1386.             // Make the API call
  1387.             $client = new Client(['verify' => false]);
  1388.             $response = $client->request('GET', $url, [
  1389.                 'auth' => [$this->username, $this->password],
  1390.             ]);
  1392.             $statusCode = $response->getStatusCode();
  1393.             $data = json_decode($response->getBody(), true);
  1395.             return $data;
  1396.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1397.             return throw new \Exception($e->getMessage());
  1398.         } catch (\Exception $e) {
  1399.             return throw new \Exception($e->getMessage());
  1400.         }
  1401.     }
  1403.     /**
  1404.      * Get weather symbols
  1405.      *
  1406.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1407.      * @param int $days The number of days for which forecast is required
  1408.      * @return array The model forecast data
  1409.      */
  1410.     public function getWeatherSymbols(array $coordinates, string $startDate, string $endDate, string $weatherFirstParam = 'PT1H', string $weatherSecondParam = '1h', $adjustDate = false)
  1411.     {
  1412.         try {
  1414.             if ($coordinates) {
  1415.                 $latitude = $coordinates[0][0];
  1416.                 $longitude = $coordinates[0][1];
  1417.             }
  1419.             // Validate the input parameters
  1420.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1421.                 throw new \InvalidArgumentException('Invalid latitude');
  1422.             }
  1423.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1424.                 throw new \InvalidArgumentException('Invalid longitude');
  1425.             }
  1427.             if (empty($startDate) || empty($endDate)) {
  1428.                 throw new \InvalidArgumentException('Invalid dates');
  1429.             }
  1432.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1433.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1435.             if ($adjustDate) {
  1436.                 // Adjust the date range based on the hours parameter
  1437.                 if ($weatherSecondParam == '24h') {
  1438.                     $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  1439.                     $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  1440.                 } elseif ($weatherSecondParam == '1h') {
  1441.                     $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  1442.                     $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  1443.                 } elseif ($weatherSecondParam == '12h') {
  1444.                     $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +12 hour'));
  1445.                     $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +12 hour'));
  1446.                 }
  1447.             }
  1449.             // Create a Redis key for the cache            
  1450.             $cacheKey = sprintf('get_symbols_%s_%s', implode('_', array_map(function ($coordinate) {
  1451.                 return implode('_', $coordinate);
  1452.             }, $coordinates)), (($startDate) . '-' . ($endDate)) . $weatherFirstParam);
  1455.             // Try to get the data from Redis cache
  1456.             $cachedData = $this->redisCache->get($cacheKey);
  1458.             if ($cachedData !== null) {
  1459.                 // Return the cached data if available
  1460.                 return $cachedData;
  1461.             }
  1463.             // If cache is empty, get the data from the API
  1464.             $client = new Client(['verify' => false]);
  1465.             $url = sprintf(
  1466.                 '%s/%s--%s:%s/weather_symbol_%s:idx/%s,%s/json?use_decluttered=true',
  1467.                 $this->apiBaseUrl,
  1468.                 $startDate,
  1469.                 $endDate,
  1470.                 $weatherFirstParam,
  1471.                 $weatherSecondParam,
  1472.                 $latitude,
  1473.                 $longitude
  1474.             );
  1477.             $response = $client->request('GET', $url, [
  1478.                 'auth' => [$this->username, $this->password],
  1479.             ]);
  1481.             $statusCode = $response->getStatusCode();
  1482.             $data = json_decode($response->getBody(), true);
  1484.             if ($adjustDate) {
  1485.                 // Define your adjustment ('-1 day' or '-1 hour' or '-12 hour')
  1487.                 if ($weatherSecondParam == '24h') {
  1488.                     $timeAdjustment = 24;
  1489.                 } elseif ($weatherSecondParam == '1h') {
  1490.                     $timeAdjustment = 1;
  1491.                 } elseif ($weatherSecondParam == '12h') {
  1492.                     $timeAdjustment = 12;
  1493.                 }
  1496.                 // Adjust the dates in the response data
  1497.                 $this->adjustResponseDates($data['data'], $timeAdjustment);
  1498.             }
  1500.             // Set the data to Redis cache
  1501.             $this->redisCache->set($cacheKey, $data);
  1503.             return $data;
  1504.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1505.             return throw new \Exception($e->getMessage());
  1506.         } catch (\Exception $e) {
  1507.             return throw new \Exception($e->getMessage());
  1508.         }
  1509.     }
  1511.     /**
  1512.      * Weather Map
  1513.      *
  1514.      * @param string $version The version of the API (e.g., '1.3.0')
  1515.      * @param string $request The type of request (e.g., 'GetMap')
  1516.      * @param string $layers The layers to include in the map
  1517.      * @param string $crs The coordinate reference system (e.g., 'EPSG:3857')
  1518.      * @param string $bBox The bounding box in the format 'minX,minY,maxX,maxY'
  1519.      * @param string $format The format of the map image (e.g., 'image/png')
  1520.      * @param int $width The width of the map image
  1521.      * @param int $height The height of the map image
  1522.      * @param bool $tiled Whether to use tiled rendering (default: true)
  1523.      * @return array The model forecast data
  1524.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  1525.      */
  1526.     public function getWeatherMap(
  1527.         string $version,
  1528.         string $request,
  1529.         string $layers,
  1530.         string $crs,
  1531.         string $bBox,
  1532.         string $format,
  1533.         int $width,
  1534.         int $height,
  1535.         bool $tiled = true
  1536.     ) {
  1537.         // Validate data types of input parameters
  1538.         if (!is_string($version)) {
  1539.             throw new \InvalidArgumentException('Invalid data type for $version. Expected string.');
  1540.         }
  1541.         if (!is_string($request)) {
  1542.             throw new \InvalidArgumentException('Invalid data type for $request. Expected string.');
  1543.         }
  1544.         if (!is_string($layers)) {
  1545.             throw new \InvalidArgumentException('Invalid data type for $layers. Expected string.');
  1546.         }
  1547.         if (!is_string($crs)) {
  1548.             throw new \InvalidArgumentException('Invalid data type for $crs. Expected string.');
  1549.         }
  1550.         if (!is_string($bBox)) {
  1551.             throw new \InvalidArgumentException('Invalid data type for $bBox. Expected string.');
  1552.         }
  1553.         if (!is_string($format)) {
  1554.             throw new \InvalidArgumentException('Invalid data type for $format. Expected string.');
  1555.         }
  1556.         if (!is_int($width)) {
  1557.             throw new \InvalidArgumentException('Invalid data type for $width. Expected int.');
  1558.         }
  1559.         if (!is_int($height)) {
  1560.             throw new \InvalidArgumentException('Invalid data type for $height. Expected int.');
  1561.         }
  1562.         if (!is_bool($tiled)) {
  1563.             throw new \InvalidArgumentException('Invalid data type for $tiled. Expected bool.');
  1564.         }
  1566.         try {
  1567.             // If cache is empty, get the data from the API
  1568.             $client = new Client(['verify' => false]);
  1569.             $url = sprintf(
  1570.                 '%s/wms?VERSION=%s&REQUEST=%s&LAYERS=%s&CRS=%s&BBOX=%s&FORMAT=%s&WIDTH=%s&HEIGHT=%s&TILED=%s&use_decluttered=true',
  1571.                 $this->apiBaseUrl,
  1572.                 $version,
  1573.                 $request,
  1574.                 $layers,
  1575.                 $crs,
  1576.                 $bBox,
  1577.                 $format,
  1578.                 $width,
  1579.                 $height,
  1580.                 $tiled
  1581.             );
  1582.             $response = $client->request('GET', $url, [
  1583.                 'auth' => [$this->username, $this->password],
  1584.             ]);
  1585.             return $response->getBody();
  1586.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1587.             return throw new \Exception($e->getMessage());
  1588.         } catch (\Exception $e) {
  1589.             return throw new \Exception($e->getMessage());
  1590.         }
  1591.     }
  1594.     /**
  1595.      * Weather Warnings
  1596.      *
  1597.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1598.      * @param string $startDate The start date for the forecast
  1599.      * @param string $endDate The end date for the forecast
  1600.      * @param string $duration The duration for the forecast (default: '24')
  1601.      * @param string $warningParam The type of weather warning parameter (default: 'frost_warning')
  1602.      * @param string $format The format of the forecast data (default: 'json')
  1603.      * @return array The model forecast data
  1604.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1605.      */
  1606.     public function getWeatherWarnings(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $warningParam = 'frost_warning', string $format = "json", $translator)
  1607.     {
  1608.         try {
  1610.             // Validate the input parameters
  1611.             if (empty($coordinates)) {
  1612.                 // throw new \InvalidArgumentException('Invalid coordinates');
  1613.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1614.             }
  1616.             if (!is_array($coordinates) || count($coordinates) < 1) {
  1617.                 // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  1618.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  1619.             }
  1621.             $latitude = $coordinates[0][0] ?? null;
  1622.             $longitude = $coordinates[0][1] ?? null;
  1624.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1625.                 // throw new \InvalidArgumentException('Invalid latitude');
  1626.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  1627.             }
  1629.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1630.                 // throw new \InvalidArgumentException('Invalid longitude');
  1631.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  1632.             }
  1634.             if (empty($startDate) || empty($endDate)) {
  1635.                 // throw new \InvalidArgumentException('Invalid dates');
  1636.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1637.             }
  1639.             if (!is_numeric($duration)) {
  1640.                 // throw new \InvalidArgumentException('Duration should be numeric');
  1641.                 return ["success" => false, "message" => $translator->trans("duration_should_be _numeric")];
  1642.             }
  1644.             $weatherWarning = new \Pimcore\Model\DataObject\MMWarningConfig\Listing();
  1645.             $weatherWarning->setCondition("WarningKey = ? AND (hourEnd >= ? AND hourStart <= ?)", [$warningParam, $duration, $duration]);
  1646.             $weatherWarning = $weatherWarning->load();
  1648.             if (!$weatherWarning) {
  1649.                 throw new \Exception('Weather configuration is missing for key.' . $warningParam);
  1650.             }
  1652.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1653.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1655.             // Create a Redis key for the cache            
  1656.             $cacheKey = sprintf('weather_warning_%s_%s_%s', $warningParam . $format, implode('_', array_map(function ($coordinate) {
  1657.                 return implode('_', $coordinate);
  1658.             }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1661.             // Try to get the data from Redis cache
  1662.             $cachedData = $this->redisCache->get($cacheKey);
  1664.             if ($cachedData !== null) {
  1665.                 // Return the cached data if available
  1666.                 return $cachedData;
  1667.             }
  1669.             // If cache is empty, get the data from the API
  1670.             $client = new Client(['verify' => false]);
  1671.             $url = sprintf(
  1672.                 '%s/%s--%s:PT%sH//%s_%sh:idx/%s,%s/json?use_decluttered=true',
  1673.                 $this->apiBaseUrl,
  1674.                 $startDate,
  1675.                 $endDate,
  1676.                 $duration,
  1677.                 $warningParam,
  1678.                 $duration,
  1679.                 $latitude,
  1680.                 $longitude
  1681.             );
  1684.             $response = $client->request('GET', $url, [
  1685.                 'auth' => [$this->username, $this->password],
  1686.             ]);
  1688.             $statusCode = $response->getStatusCode();
  1689.             $data = json_decode($response->getBody(), true);
  1690.             $modifiedParams = [];
  1691.             if (isset($data['data'][0]['coordinates'][0]['dates'])) {
  1692.                 foreach ($data['data'][0]['coordinates'][0]['dates'] as $weather) {
  1693.                     $data = \App\Lib\Utility::getWeatherTypeDescription($weatherWarning[0]->getParams(), $weather);
  1694.                     $modifiedParams[] = $data;
  1695.                 }
  1696.             }
  1698.             $data['data'] = $modifiedParams;
  1700.             // Set the data to Redis cache
  1701.             $this->redisCache->set($cacheKey, $data);
  1703.             return $data;
  1704.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1705.             return throw new \Exception($e->getMessage());
  1706.         } catch (\Exception $e) {
  1707.             return throw new \Exception($e->getMessage());
  1708.         }
  1709.     }
  1712.     /**
  1713.      * Weather Warnings
  1714.      *
  1715.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1716.      * @param string $startDate The start date for the forecast
  1717.      * @param string $endDate The end date for the forecast
  1718.      * @param string $duration The duration for the forecast (default: '24')
  1719.      * @param string $warningParam The type of weather warning parameter (default: 'frost_warning')
  1720.      * @param string $format The format of the forecast data (default: 'json')
  1721.      * @return array The model forecast data
  1722.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1723.      */
  1724.     public function getPrecipitationType(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  1725.     {
  1726.         try {
  1728.             // Validate the input parameters
  1729.             if (empty($coordinates)) {
  1730.                 // throw new \InvalidArgumentException('Invalid coordinates');
  1731.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1732.             }
  1734.             if (!is_array($coordinates) || count($coordinates) < 1) {
  1735.                 // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  1736.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  1737.             }
  1739.             $latitude = $coordinates[0][0] ?? null;
  1740.             $longitude = $coordinates[0][1] ?? null;
  1742.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1743.                 // throw new \InvalidArgumentException('Invalid latitude');
  1744.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  1745.             }
  1747.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1748.                 // throw new \InvalidArgumentException('Invalid longitude');
  1749.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  1750.             }
  1752.             if (empty($startDate) || empty($endDate)) {
  1753.                 // throw new \InvalidArgumentException('Invalid dates');
  1754.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1755.             }
  1757.             if (!is_numeric($duration)) {
  1758.                 // throw new \InvalidArgumentException('Duration should be numeric');
  1759.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1760.             }
  1763.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1764.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1766.             // Create a Redis key for the cache            
  1767.             $cacheKey = sprintf('weather_precitipitation_%s_%s', implode('_', array_map(function ($coordinate) {
  1768.                 return implode('_', $coordinate);
  1769.             }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1772.             // Try to get the data from Redis cache
  1773.             $cachedData = $this->redisCache->get($cacheKey);
  1775.             if ($cachedData !== null) {
  1776.                 // Return the cached data if available
  1777.                 // return $cachedData;
  1778.             }
  1780.             // If cache is empty, get the data from the API
  1781.             $client = new Client(['verify' => false]);
  1782.             $url = sprintf(
  1783.                 '%s/%s--%s:PT%sM/precip_type:idx/%s,%s/json?use_decluttered=true',
  1784.                 $this->apiBaseUrl,
  1785.                 $startDate,
  1786.                 $endDate,
  1787.                 $duration,
  1788.                 $duration,
  1789.                 $latitude,
  1790.                 $longitude
  1791.             );
  1794.             $response = $client->request('GET', $url, [
  1795.                 'auth' => [$this->username, $this->password],
  1796.             ]);
  1798.             $statusCode = $response->getStatusCode();
  1799.             $data = json_decode($response->getBody(), true);
  1801.             $modifiedParams = [];
  1802.             if (isset($data['data'][0]['coordinates'][0]['dates'])) {
  1803.                 foreach ($data['data'][0]['coordinates'][0]['dates'] as $prepData) {
  1804.                     $data = \App\Lib\Utility::getPrecipitationTypeDescription($prepData);
  1805.                     $modifiedParams[] = $data;
  1806.                 }
  1807.             } else {
  1808.                 throw new \Exception("Data not available");
  1809.             }
  1811.             $data['data'][0]['coordinates'][0]['dates'] = $modifiedParams;
  1813.             // Set the data to Redis cache
  1814.             $this->redisCache->set($cacheKey, $data);
  1816.             return $data;
  1817.         } catch (GuzzleHttp\Exception\RequestException $e) {
  1818.             return throw new \Exception($e->getMessage());
  1819.         } catch (\Exception $e) {
  1820.             return throw new \Exception($e->getMessage());
  1821.         }
  1822.     }
  1825.     /**
  1826.      * Weather Warnings
  1827.      *
  1828.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1829.      * @param string $startDate The start date for the forecast
  1830.      * @param string $endDate The end date for the forecast
  1831.      * @param string $duration The duration for the forecast (default: '24')
  1832.      * @param string $intervalType type of interval (default: 'min')
  1833.      * @param string $format The format of the forecast data (default: 'json')
  1834.      * @return array The model forecast data
  1835.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1836.      */
  1837.     public function getHailIndex(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $intervalType = "min", string $format = "json", $translator)
  1838.     {
  1839.         try {
  1841.             // Validate the input parameters
  1842.             if (count($coordinates) > 1) {
  1844.                 // Validate the input parameters
  1845.                 foreach ($coordinates as $coordinate) {
  1846.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1847.                         throw new \InvalidArgumentException('Invalid coordinates');
  1848.                     }
  1849.                 }
  1851.                 if (empty($startDate) || empty($endDate)) {
  1852.                     // throw new \InvalidArgumentException('Invalid dates');
  1853.                     return ["success" => false, "message" => $translator->trans("duration_dates")];
  1854.                 }
  1856.                 if (!is_numeric($duration)) {
  1857.                     // throw new \InvalidArgumentException('Duration should be numeric');
  1858.                     return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1859.                 }
  1861.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1862.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1864.                 // Create a Redis key for the cache            
  1865.                 $cacheKey = sprintf('weather_hail_%s_%s', implode('_', array_map(function ($coordinate) {
  1866.                     return implode('_', $coordinate);
  1867.                 }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  1870.                 // Try to get the data from Redis cache
  1871.                 $cachedData = $this->redisCache->get($cacheKey);
  1873.                 if ($cachedData !== null) {
  1874.                     // Return the cached data if available
  1875.                     return $cachedData;
  1876.                 }
  1879.                 // If cache is empty, get the data from the API
  1880.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1882.                 //10min, 20min, 30min, 1h, 3h, 6h, 12h, 24h
  1883.                 // If cache is empty, get the data from the API
  1884.                 if ($intervalType == "min") {
  1885.                     $url = sprintf(
  1886.                         '%s/%s--%s:PT%sM/hail_%smin:cm/%s/json?use_decluttered=true',
  1887.                         $this->apiBaseUrl,
  1888.                         $startDate,
  1889.                         $endDate,
  1890.                         $duration,
  1891.                         $duration,
  1892.                         $coordinateString
  1893.                     );
  1894.                 } else if ($intervalType == "hour") {
  1895.                     $url = sprintf(
  1896.                         '%s/%s--%s:PT%sH/hail_%sh:cm/%s/json?use_decluttered=true',
  1897.                         $this->apiBaseUrl,
  1898.                         $startDate,
  1899.                         $endDate,
  1900.                         $duration,
  1901.                         $duration,
  1902.                         $coordinateString
  1903.                     );
  1904.                 }
  1906.                 $client = new Client(['verify' => false]);
  1909.                 $response = $client->request('GET', $url, [
  1910.                     'auth' => [$this->username, $this->password],
  1911.                 ]);
  1913.                 $statusCode = $response->getStatusCode();
  1914.                 $data = json_decode($response->getBody(), true);
  1916.                 // Set the data to Redis cache
  1917.                 $this->redisCache->set($cacheKey, $data);
  1919.                 return $data;
  1920.             } else {
  1923.                 $latitude = $coordinates[0][0] ?? null;
  1924.                 $longitude = $coordinates[0][1] ?? null;
  1926.                 if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1927.                     // throw new \InvalidArgumentException('Invalid latitude');
  1928.                     return ["success" => false, "message" => $translator->trans("duration_latitude")];
  1929.                 }
  1931.                 if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1932.                     // throw new \InvalidArgumentException('Invalid longitude');
  1933.                     return ["success" => false, "message" => $translator->trans("duration_longitude")];
  1934.                 }
  1936.                 if (empty($startDate) || empty($endDate)) {
  1937.                     // throw new \InvalidArgumentException('Invalid dates');
  1938.                     return ["success" => false, "message" => $translator->trans("duration_dates")];
  1939.                 }
  1941.                 if (!is_numeric($duration)) {
  1942.                     // throw new \InvalidArgumentException('Duration should be numeric');
  1943.                     return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1944.                 }
  1947.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1948.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1950.                 // Create a Redis key for the cache            
  1951.                 $cacheKey = sprintf('weather_hail_%s_%s', implode('_', array_map(function ($coordinate) {
  1952.                     return implode('_', $coordinate);
  1953.                 }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  1956.                 // Try to get the data from Redis cache
  1957.                 $cachedData = $this->redisCache->get($cacheKey);
  1959.                 if ($cachedData !== null) {
  1960.                     // Return the cached data if available
  1961.                     return $cachedData;
  1962.                 }
  1964.                 //10min, 20min, 30min, 1h, 3h, 6h, 12h, 24h
  1965.                 // If cache is empty, get the data from the API
  1966.                 if ($intervalType == "min") {
  1967.                     $url = sprintf(
  1968.                         '%s/%s--%s:PT%sM/hail_%smin:cm/%s,%s/json?use_decluttered=true',
  1969.                         $this->apiBaseUrl,
  1970.                         $startDate,
  1971.                         $endDate,
  1972.                         $duration,
  1973.                         $duration,
  1974.                         $latitude,
  1975.                         $longitude
  1976.                     );
  1977.                 } else if ($intervalType == "hour") {
  1978.                     $url = sprintf(
  1979.                         '%s/%s--%s:PT%sH/hail_%sh:cm/%s,%s/json?use_decluttered=true',
  1980.                         $this->apiBaseUrl,
  1981.                         $startDate,
  1982.                         $endDate,
  1983.                         $duration,
  1984.                         $duration,
  1985.                         $latitude,
  1986.                         $longitude
  1987.                     );
  1988.                 }
  1990.                 $client = new Client(['verify' => false]);
  1993.                 $response = $client->request('GET', $url, [
  1994.                     'auth' => [$this->username, $this->password],
  1995.                 ]);
  1997.                 $statusCode = $response->getStatusCode();
  1998.                 $data = json_decode($response->getBody(), true);
  2000.                 // Set the data to Redis cache
  2001.                 $this->redisCache->set($cacheKey, $data);
  2003.                 return $data;
  2004.             }
  2005.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2006.             return throw new \Exception($e->getMessage());
  2007.         } catch (\Exception $e) {
  2008.             return throw new \Exception($e->getMessage());
  2009.         }
  2010.     }
  2012.     /**
  2013.      * Temprature
  2014.      *
  2015.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2016.      * @param string $startDate The start date for the forecast
  2017.      * @param string $endDate The end date for the forecast
  2018.      * @param string $duration The duration for the forecast (default: '24')
  2019.      * @param string $intervalType type of interval (default: 'hour')
  2020.      * @param string $format The format of the forecast data (default: 'json')
  2021.      * @return array The model forecast data
  2022.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2023.      */
  2025.     //https://api.meteomatics.com/2023-07-11T00:00:00Z--2023-07-14T00:00:00Z:PT1H/t_2m:C/48.8566,2.3522/json
  2026.     public function getTemprature(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $intervalType = "hour", string $format = "json", $translator)
  2027.     {
  2028.         try {
  2030.             // Validate the input parameters
  2031.             if (empty($coordinates)) {
  2032.                 // throw new \InvalidArgumentException('Invalid coordinates');
  2033.                 return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2034.             }
  2036.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2037.                 // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  2038.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2039.             }
  2041.             $latitude = $coordinates[0][0] ?? null;
  2042.             $longitude = $coordinates[0][1] ?? null;
  2044.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2045.                 // throw new \InvalidArgumentException('Invalid latitude');
  2046.                 return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2047.             }
  2049.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2050.                 // throw new \InvalidArgumentException('Invalid longitude');
  2051.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2052.             }
  2054.             if (empty($startDate) || empty($endDate)) {
  2055.                 // throw new \InvalidArgumentException('Invalid dates');
  2056.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2057.             }
  2059.             if (!is_numeric($duration)) {
  2060.                 // throw new \InvalidArgumentException('Duration should be numeric');
  2061.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2062.             }
  2065.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2066.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2068.             // Create a Redis key for the cache            
  2069.             $cacheKey = sprintf('temprature_%s_%s', implode('_', array_map(function ($coordinate) {
  2070.                 return implode('_', $coordinate);
  2071.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  2074.             // Try to get the data from Redis cache
  2075.             $cachedData = $this->redisCache->get($cacheKey);
  2077.             if ($cachedData !== null) {
  2078.                 // Return the cached data if available
  2079.                 return $cachedData;
  2080.             }
  2082.             // If cache is empty, get the data from the API
  2083.             if ($intervalType == "hour") {
  2084.                 $url = sprintf(
  2085.                     '%s/%s--%s:PT%sM/t_2m:C/%s,%s/json?use_decluttered=true',
  2086.                     $this->apiBaseUrl,
  2087.                     $startDate,
  2088.                     $endDate,
  2089.                     $duration,
  2090.                     $latitude,
  2091.                     $longitude
  2092.                 );
  2093.             } else if ($intervalType == "day") {
  2094.                 $url = sprintf(
  2095.                     '%s/%s--%s:P%sD/t_2m:C/%s,%s/json?use_decluttered=true',
  2096.                     $this->apiBaseUrl,
  2097.                     $startDate,
  2098.                     $endDate,
  2099.                     $duration,
  2100.                     $latitude,
  2101.                     $longitude
  2102.                 );
  2103.             }
  2105.             $client = new Client(['verify' => false]);
  2108.             $response = $client->request('GET', $url, [
  2109.                 'auth' => [$this->username, $this->password],
  2110.             ]);
  2112.             $statusCode = $response->getStatusCode();
  2113.             $data = json_decode($response->getBody(), true);
  2115.             // Set the data to Redis cache
  2116.             $this->redisCache->set($cacheKey, $data);
  2118.             return $data;
  2119.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2120.             return throw new \Exception($e->getMessage());
  2121.         } catch (\Exception $e) {
  2122.             return throw new \Exception($e->getMessage());
  2123.         }
  2124.     }
  2126.     /**
  2127.      * Precipitation Probability
  2128.      *
  2129.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2130.      * @param string $startDate The start date for the forecast
  2131.      * @param string $endDate The end date for the forecast
  2132.      * @param string $duration The duration for the forecast (default: '24')
  2133.      * @param string $intervalType type of interval (default: 'hour')
  2134.      * @param string $format The format of the forecast data (default: 'json')
  2135.      * @return array The model forecast data
  2136.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2137.      */
  2139.     //https://api.meteomatics.com/2023-07-11T00:00:00Z--2023-07-14T00:00:00Z:PT1H/t_2m:C/48.8566,2.3522/json
  2140.     public function getPrecipitationProbability(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  2141.     {
  2142.         try {
  2144.             // Validate the input parameters
  2145.             if (empty($coordinates)) {
  2146.                 return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2147.             }
  2149.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2150.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2151.             }
  2153.             $latitude = $coordinates[0][0] ?? null;
  2154.             $longitude = $coordinates[0][1] ?? null;
  2156.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2157.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2158.             }
  2160.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2161.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2162.             }
  2164.             if (empty($startDate) || empty($endDate)) {
  2165.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2166.             }
  2168.             if (!is_numeric($duration)) {
  2169.                 // throw new \InvalidArgumentException('Duration should be numeric');
  2170.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2171.             }
  2174.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2175.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2177.             // Create a Redis key for the cache            
  2178.             $cacheKey = sprintf('precep_prob_%s_%s', implode('_', array_map(function ($coordinate) {
  2179.                 return implode('_', $coordinate);
  2180.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2183.             // Try to get the data from Redis cache
  2184.             $cachedData = $this->redisCache->get($cacheKey);
  2186.             if ($cachedData !== null) {
  2187.                 // Return the cached data if available
  2188.                 return $cachedData;
  2189.             }
  2191.             // If cache is empty, get the data from the API
  2192.             $url = sprintf(
  2193.                 '%s/%s--%s:PT%sH/prob_precip_%sh:p/%s,%s/json?use_decluttered=true',
  2194.                 $this->apiBaseUrl,
  2195.                 $startDate,
  2196.                 $endDate,
  2197.                 $duration,
  2198.                 $duration,
  2199.                 $latitude,
  2200.                 $longitude
  2201.             );
  2203.             $client = new Client(['verify' => false]);
  2206.             $response = $client->request('GET', $url, [
  2207.                 'auth' => [$this->username, $this->password],
  2208.             ]);
  2210.             $statusCode = $response->getStatusCode();
  2211.             $data = json_decode($response->getBody(), true);
  2213.             // Set the data to Redis cache
  2214.             $this->redisCache->set($cacheKey, $data);
  2216.             return $data;
  2217.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2218.             return throw new \Exception($e->getMessage());
  2219.         } catch (\Exception $e) {
  2220.             return throw new \Exception($e->getMessage());
  2221.         }
  2222.     }
  2224.     /**
  2225.      * Visibility
  2226.      *
  2227.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2228.      * @param string $startDate The start date for the forecast
  2229.      * @param string $endDate The end date for the forecast
  2230.      * @param string $duration The duration for the forecast (default: '24')
  2231.      * @param string $intervalType type of interval (default: 'hour')
  2232.      * @param string $format The format of the forecast data (default: 'json')
  2233.      * @return array The model forecast data
  2234.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2235.      */
  2236.     public function getVisibility(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'km', string $format = "json", $translator)
  2237.     {
  2238.         try {
  2240.             // Validate the input parameters
  2241.             if (empty($coordinates)) {
  2242.                 // throw new \InvalidArgumentException('Invalid coordinates');
  2243.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2244.             }
  2246.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2247.                 // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  2248.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2249.             }
  2251.             $latitude = $coordinates[0][0] ?? null;
  2252.             $longitude = $coordinates[0][1] ?? null;
  2254.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2255.                 // throw new \InvalidArgumentException('Invalid latitude');
  2256.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2257.             }
  2259.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2260.                 // throw new \InvalidArgumentException('Invalid longitude');
  2261.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2262.             }
  2264.             if (empty($startDate) || empty($endDate)) {
  2265.                 // throw new \InvalidArgumentException('Invalid dates');
  2266.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2267.             }
  2269.             if (!is_numeric($duration)) {
  2270.                 // throw new \InvalidArgumentException('Duration should be numeric');
  2271.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2272.             }
  2274.             if (!in_array($unit, ['m', 'km', 'ft', 'nmi'])) {
  2275.                 // throw new \InvalidArgumentException('Invalid unit');
  2276.                 return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2277.             }
  2280.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2281.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2283.             // Create a Redis key for the cache            
  2284.             $cacheKey = sprintf('visibility_%s_%s', implode('_', array_map(function ($coordinate) {
  2285.                 return implode('_', $coordinate);
  2286.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2289.             // Try to get the data from Redis cache
  2290.             $cachedData = $this->redisCache->get($cacheKey);
  2292.             if ($cachedData !== null) {
  2293.                 // Return the cached data if available
  2294.                 return $cachedData;
  2295.             }
  2297.             // If cache is empty, get the data from the API
  2298.             $url = sprintf(
  2299.                 '%s/%s--%s:PT%sH/visibility:%s/%s,%s/json?use_decluttered=true',
  2300.                 $this->apiBaseUrl,
  2301.                 $startDate,
  2302.                 $endDate,
  2303.                 $duration,
  2304.                 $unit,
  2305.                 $latitude,
  2306.                 $longitude
  2307.             );
  2309.             $client = new Client(['verify' => false]);
  2312.             $response = $client->request('GET', $url, [
  2313.                 'auth' => [$this->username, $this->password],
  2314.             ]);
  2316.             $statusCode = $response->getStatusCode();
  2317.             $data = json_decode($response->getBody(), true);
  2319.             // Set the data to Redis cache
  2320.             $this->redisCache->set($cacheKey, $data);
  2322.             return $data;
  2323.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2324.             return throw new \Exception($e->getMessage());
  2325.         } catch (\Exception $e) {
  2326.             return throw new \Exception($e->getMessage());
  2327.         }
  2328.     }
  2330.     /**
  2331.      * Wind Direction
  2332.      *
  2333.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2334.      * @param string $startDate The start date for the forecast
  2335.      * @param string $endDate The end date for the forecast
  2336.      * @param string $duration The duration for the forecast (default: '24')
  2337.      * @param string $intervalType type of interval (default: 'hour')
  2338.      * @param string $format The format of the forecast data (default: 'json')
  2339.      * @return array The model forecast data
  2340.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2341.      */
  2342.     //https://api.meteomatics.com/2023-07-11T00:00:00ZP2D:PT3H/wind_dir_10m:d,wind_dir_700hPa:d/47.412164,9.340652/csv
  2343.     public function getWindDirection(array $coordinates, string $startDate, string $endDate, string $duration = '24', $height = '10m', $level = '700hPa', string $format = "json", $translator)
  2344.     {
  2345.         try {
  2347.             // Validate the input parameters
  2348.             if (empty($coordinates)) {
  2349.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2350.             }
  2352.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2353.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2354.             }
  2356.             $latitude = $coordinates[0][0] ?? null;
  2357.             $longitude = $coordinates[0][1] ?? null;
  2359.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2360.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2361.             }
  2363.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2364.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2365.             }
  2367.             if (empty($startDate) || empty($endDate)) {
  2368.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2369.             }
  2371.             if (!is_numeric($duration)) {
  2372.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2373.             }
  2375.             if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2376.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  2377.             }
  2380.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2381.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2383.             // Create a Redis key for the cache            
  2384.             $cacheKey = sprintf('wind_direction_%s_%s', implode('_', array_map(function ($coordinate) {
  2385.                 return implode('_', $coordinate);
  2386.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $level));
  2389.             // Try to get the data from Redis cache
  2390.             $cachedData = $this->redisCache->get($cacheKey);
  2392.             if ($cachedData !== null) {
  2393.                 // Return the cached data if available
  2394.                 return $cachedData;
  2395.             }
  2397.             // If cache is empty, get the data from the API
  2398.             $url = sprintf(
  2399.                 '%s/%s--%s:PT%sH/wind_dir_%s:d,wind_dir_%s:d/%s,%s/json?use_decluttered=true',
  2400.                 $this->apiBaseUrl,
  2401.                 $startDate,
  2402.                 $endDate,
  2403.                 $duration,
  2404.                 $height,
  2405.                 $level,
  2406.                 $latitude,
  2407.                 $longitude
  2408.             );
  2410.             $client = new Client(['verify' => false]);
  2413.             $response = $client->request('GET', $url, [
  2414.                 'auth' => [$this->username, $this->password],
  2415.             ]);
  2417.             $statusCode = $response->getStatusCode();
  2418.             $data = json_decode($response->getBody(), true);
  2420.             // Set the data to Redis cache
  2421.             $this->redisCache->set($cacheKey, $data);
  2423.             return $data;
  2424.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2425.             return throw new \Exception($e->getMessage());
  2426.         } catch (\Exception $e) {
  2427.             return throw new \Exception($e->getMessage());
  2428.         }
  2429.     }
  2432.     /**
  2433.      * Wind Speed
  2434.      *
  2435.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2436.      * @param string $startDate The start date for the forecast
  2437.      * @param string $endDate The end date for the forecast
  2438.      * @param string $duration The duration for the forecast (default: '24')
  2439.      * @param string $intervalType type of interval (default: 'hour')
  2440.      * @param string $format The format of the forecast data (default: 'json')
  2441.      * @return array The model forecast data
  2442.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2443.      */
  2444.     public function getWindSpeed(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'ft', $level = '700hPa', string $format = "json", $translator)
  2445.     {
  2446.         try {
  2448.             // Validate the input parameters
  2449.             if (empty($coordinates)) {
  2450.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2451.             }
  2453.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2454.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2455.             }
  2457.             $latitude = $coordinates[0][0] ?? null;
  2458.             $longitude = $coordinates[0][1] ?? null;
  2460.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2461.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2462.             }
  2464.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2465.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2466.             }
  2468.             if (empty($startDate) || empty($endDate)) {
  2469.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2470.             }
  2472.             if (!is_numeric($duration)) {
  2473.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2474.             }
  2476.             if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2477.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  2478.             }
  2480.             if (!in_array($unit, ['ms', 'kmh', 'mph', 'kn', 'bft'])) {
  2481.                 return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2482.             }
  2485.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2486.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2488.             // Create a Redis key for the cache            
  2489.             $cacheKey = sprintf('wind_speed_%s_%s', implode('_', array_map(function ($coordinate) {
  2490.                 return implode('_', $coordinate);
  2491.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $unit . $level));
  2494.             // Try to get the data from Redis cache
  2495.             $cachedData = $this->redisCache->get($cacheKey);
  2497.             if ($cachedData !== null) {
  2498.                 // Return the cached data if available
  2499.                 return $cachedData;
  2500.             }
  2502.             // If cache is empty, get the data from the API
  2503.             $url = sprintf(
  2504.                 '%s/%s--%s:PT%sH/wind_speed_%s:%s/%s,%s/json?use_decluttered=true',
  2505.                 $this->apiBaseUrl,
  2506.                 $startDate,
  2507.                 $endDate,
  2508.                 $duration,
  2509.                 $level,
  2510.                 $unit,
  2511.                 $latitude,
  2512.                 $longitude
  2513.             );
  2515.             $client = new Client(['verify' => false]);
  2518.             $response = $client->request('GET', $url, [
  2519.                 'auth' => [$this->username, $this->password],
  2520.             ]);
  2522.             $statusCode = $response->getStatusCode();
  2523.             $data = json_decode($response->getBody(), true);
  2525.             // Set the data to Redis cache
  2526.             $this->redisCache->set($cacheKey, $data);
  2528.             return $data;
  2529.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2530.             return throw new \Exception($e->getMessage());
  2531.         } catch (\Exception $e) {
  2532.             return throw new \Exception($e->getMessage());
  2533.         }
  2534.     }
  2536.     /**
  2537.      * Slippery Road
  2538.      *
  2539.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2540.      * @param string $startDate The start date for the forecast
  2541.      * @param string $endDate The end date for the forecast
  2542.      * @param string $duration The duration for the forecast (default: '24')
  2543.      * @param string $intervalType type of interval (default: 'hour')
  2544.      * @param string $format The format of the forecast data (default: 'json')
  2545.      * @return array The model forecast data
  2546.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2547.      */
  2548.     public function getSlipperyRoad(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  2549.     {
  2550.         try {
  2552.             // Validate the input parameters
  2553.             if (empty($coordinates)) {
  2554.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2555.             }
  2557.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2558.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2559.             }
  2561.             $latitude = $coordinates[0][0] ?? null;
  2562.             $longitude = $coordinates[0][1] ?? null;
  2564.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2565.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2566.             }
  2568.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2569.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2570.             }
  2572.             if (empty($startDate) || empty($endDate)) {
  2573.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2574.             }
  2576.             if (!is_numeric($duration)) {
  2577.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2578.             }
  2581.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2582.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2584.             // Create a Redis key for the cache            
  2585.             $cacheKey = sprintf('slipary_road_%s_%s', implode('_', array_map(function ($coordinate) {
  2586.                 return implode('_', $coordinate);
  2587.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2590.             // Try to get the data from Redis cache
  2591.             $cachedData = $this->redisCache->get($cacheKey);
  2593.             if ($cachedData !== null) {
  2594.                 // Return the cached data if available
  2595.                 return $cachedData;
  2596.             }
  2598.             // If cache is empty, get the data from the API
  2599.             $url = sprintf(
  2600.                 '%s/%s--%s:PT%sH/prob_slippery_road_%sh:p,is_slippery_road_%sh:idx/%s,%s/json?use_decluttered=true',
  2601.                 $this->apiBaseUrl,
  2602.                 $startDate,
  2603.                 $endDate,
  2604.                 $duration,
  2605.                 $duration,
  2606.                 $duration,
  2607.                 $latitude,
  2608.                 $longitude
  2609.             );
  2611.             $client = new Client(['verify' => false]);
  2614.             $response = $client->request('GET', $url, [
  2615.                 'auth' => [$this->username, $this->password],
  2616.             ]);
  2618.             $statusCode = $response->getStatusCode();
  2619.             $data = json_decode($response->getBody(), true);
  2621.             // Set the data to Redis cache
  2622.             $this->redisCache->set($cacheKey, $data);
  2624.             return $data;
  2625.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2626.             return throw new \Exception($e->getMessage());
  2627.         } catch (\Exception $e) {
  2628.             return throw new \Exception($e->getMessage());
  2629.         }
  2630.     }
  2633.     /**
  2634.      * Solar Radiation
  2635.      *
  2636.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2637.      * @param string $startDate The start date for the forecast
  2638.      * @param string $endDate The end date for the forecast     
  2639.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2640.      */
  2641.     public function getSolarRadiation(array $coordinates, string $startDate, string $endDate, $translator, string $format = 'png',)
  2642.     {
  2643.         try {
  2645.             // Validate the input parameters
  2646.             if (empty($coordinates)) {
  2647.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2648.             }
  2650.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2651.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2652.             }
  2654.             $latitude1 = $coordinates[0][0] ?? null;
  2655.             $longitude1 = $coordinates[0][1] ?? null;
  2657.             $latitude2 = $coordinates[1][0] ?? null;
  2658.             $longitude2 = $coordinates[1][1] ?? null;
  2660.             if (!is_numeric($latitude1) || $latitude1 < -90 || $latitude1 > 90) {
  2661.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2662.             }
  2664.             if (!is_numeric($longitude1) || $longitude1 < -180 || $longitude1 > 180) {
  2665.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2666.             }
  2668.             if (!is_numeric($latitude2) || $latitude2 < -90 || $latitude2 > 90) {
  2669.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2670.             }
  2672.             if (
  2673.                 !is_numeric($longitude2) || $longitude2 < -180 || $longitude2 > 180
  2674.             ) {
  2675.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2676.             }
  2678.             if (empty($startDate) || empty($endDate)) {
  2679.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2680.             }
  2682.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2683.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2685.             $url = sprintf(
  2686.                 '%s/%s/global_rad:W/%s,%s_%s,%s:600x400/%s?use_decluttered=true',
  2687.                 $this->apiBaseUrl,
  2688.                 $startDate,
  2689.                 $latitude1,
  2690.                 $longitude1,
  2691.                 $latitude2,
  2692.                 $longitude2,
  2693.                 $format
  2694.             );
  2696.             // echo $url;
  2697.             // exit;
  2698.             $client = new Client(['verify' => false]);
  2700.             $response = $client->request('GET', $url, [
  2701.                 'auth' => [$this->username, $this->password],
  2702.             ]);
  2703.             $statusCode = $response->getStatusCode();
  2704.             return $response->getBody();
  2705.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2706.             return throw new \Exception($e->getMessage());
  2707.         } catch (\Exception $e) {
  2708.             return throw new \Exception($e->getMessage());
  2709.         }
  2710.     }
  2712.     /**
  2713.      * Humidity
  2714.      *
  2715.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2716.      * @param string $startDate The start date for the forecast
  2717.      * @param string $endDate The end date for the forecast
  2718.      * @param string $duration The duration for the forecast (default: '24')
  2719.      * @param string $intervalType type of interval (default: 'hour')
  2720.      * @param string $format The format of the forecast data (default: 'json')
  2721.      * @return array The model forecast data
  2722.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2723.      */
  2724.     public function getHumidity(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'ft', $level = '700hPa', string $format = "json", $translator)
  2725.     {
  2726.         try {
  2728.             // Validate the input parameters
  2729.             if (empty($coordinates)) {
  2730.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2731.             }
  2733.             if (!is_array($coordinates) || count($coordinates) < 1) {
  2734.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2735.             }
  2737.             $latitude = $coordinates[0][0] ?? null;
  2738.             $longitude = $coordinates[0][1] ?? null;
  2740.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2741.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2742.             }
  2744.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2745.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2746.             }
  2748.             if (empty($startDate) || empty($endDate)) {
  2749.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2750.             }
  2752.             if (!is_numeric($duration)) {
  2753.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2754.             }
  2756.             if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2757.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  2758.             }
  2760.             if (!in_array($unit, ['p'])) {
  2761.                 return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2762.             }
  2765.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2766.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2768.             // Create a Redis key for the cache            
  2769.             $cacheKey = sprintf('humidity_%s_%s', implode('_', array_map(function ($coordinate) {
  2770.                 return implode('_', $coordinate);
  2771.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $unit . $level));
  2774.             // Try to get the data from Redis cache
  2775.             $cachedData = $this->redisCache->get($cacheKey);
  2777.             if ($cachedData !== null) {
  2778.                 // Return the cached data if available
  2779.                 return $cachedData;
  2780.             }
  2782.             // If cache is empty, get the data from the API
  2783.             $url = sprintf(
  2784.                 '%s/%s--%s:PT%sH/relative_humidity_%s:%s/%s,%s/json?use_decluttered=true',
  2785.                 $this->apiBaseUrl,
  2786.                 $startDate,
  2787.                 $endDate,
  2788.                 $duration,
  2789.                 $level,
  2790.                 $unit,
  2791.                 $latitude,
  2792.                 $longitude
  2793.             );
  2795.             $client = new Client(['verify' => false]);
  2798.             $response = $client->request('GET', $url, [
  2799.                 'auth' => [$this->username, $this->password],
  2800.             ]);
  2802.             $statusCode = $response->getStatusCode();
  2803.             $data = json_decode($response->getBody(), true);
  2805.             // Set the data to Redis cache
  2806.             $this->redisCache->set($cacheKey, $data);
  2808.             return $data;
  2809.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2810.             return throw new \Exception($e->getMessage());
  2811.         } catch (\Exception $e) {
  2812.             return throw new \Exception($e->getMessage());
  2813.         }
  2814.     }
  2816.     /**
  2817.      * Fog
  2818.      *
  2819.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2820.      * @param string $startDate The start date for the forecast
  2821.      * @param string $endDate The start date for the forecast
  2822.      * @param string $interval Hours gap between search results
  2823.      * @param string $intervalType type of interval (default: 'hour')
  2824.      * @param string $format The format of the forecast data (default: 'json')
  2825.      * @return array The model forecast data
  2826.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2827.      */
  2828.     public function getFog(array $coordinates, string $startDate, string $endDate, string $interval = '1', $unit = 'km', $translator,  string $format = "json")
  2829.     {
  2830.         try {
  2832.             if (count($coordinates) > 1) {
  2834.                 // Validate the input parameters
  2835.                 foreach ($coordinates as $coordinate) {
  2836.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  2837.                         throw new \InvalidArgumentException('Invalid coordinates');
  2838.                     }
  2839.                 }
  2841.                 if (empty($startDate)) {
  2842.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2843.                 }
  2845.                 if (empty($endDate)) {
  2846.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2847.                 }
  2849.                 if (!is_numeric($interval)) {
  2850.                     return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  2851.                 }
  2853.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2854.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2856.                 // Create a Redis key for the cache            
  2857.                 $cacheKey = sprintf('visibility:%s,is_fog_%sh:idx', implode('_', array_map(function ($coordinate) {
  2858.                     return implode('_', $coordinate);
  2859.                 }, $coordinates)), (($startDate) . '-' . $endDate . $interval . $unit));
  2863.                 // Try to get the data from Redis cache
  2864.                 $cachedData = $this->redisCache->get($cacheKey);
  2866.                 if ($cachedData !== null) {
  2867.                     // Return the cached data if available
  2868.                     return $cachedData;
  2869.                 }
  2871.                 // If cache is empty, get the data from the API
  2872.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  2874.                 // If cache is empty, get the data from the API           
  2875.                 $url = sprintf(
  2876.                     '%s/%s--%s:PT%sH/visibility:%s,is_fog_%sh:idx/%s/json?use_decluttered=true',
  2877.                     $this->apiBaseUrl,
  2878.                     $startDate,
  2879.                     $endDate,
  2880.                     $interval,
  2881.                     $unit,
  2882.                     $interval,
  2883.                     $coordinateString
  2884.                 );
  2887.                 $client = new Client(['verify' => false]);
  2890.                 $response = $client->request('GET', $url, [
  2891.                     'auth' => [$this->username, $this->password],
  2892.                 ]);
  2894.                 $statusCode = $response->getStatusCode();
  2895.                 $data = json_decode($response->getBody(), true);
  2897.                 // Set the data to Redis cache
  2898.                 $this->redisCache->set($cacheKey, $data);
  2900.                 return $data;
  2901.             } else {
  2903.                 // Validate the input parameters
  2904.                 if (empty($coordinates)) {
  2905.                     return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2906.                 }
  2908.                 if (!is_array($coordinates) || count($coordinates) < 1) {
  2909.                     return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2910.                 }
  2912.                 $latitude = $coordinates[0][0] ?? null;
  2913.                 $longitude = $coordinates[0][1] ?? null;
  2915.                 if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2916.                     return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2917.                 }
  2919.                 if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2920.                     return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2921.                 }
  2923.                 if (empty($startDate)) {
  2924.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2925.                 }
  2927.                 if (empty($endDate)) {
  2928.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2929.                 }
  2931.                 if (!is_numeric($interval)) {
  2932.                     return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  2933.                 }
  2935.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2936.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2938.                 // Create a Redis key for the cache            
  2939.                 $cacheKey = sprintf('visibility:%s,is_fog_%sh:idx', implode('_', array_map(function ($coordinate) {
  2940.                     return implode('_', $coordinate);
  2941.                 }, $coordinates)), (($startDate) . '-' . $endDate . $interval . $unit));
  2944.                 // Try to get the data from Redis cache
  2945.                 $cachedData = $this->redisCache->get($cacheKey);
  2947.                 if ($cachedData !== null) {
  2948.                     // Return the cached data if available
  2949.                     return $cachedData;
  2950.                 }
  2952.                 // If cache is empty, get the data from the API           
  2953.                 $url = sprintf(
  2954.                     '%s/%s--%s:PT%sH/visibility:%s,is_fog_%sh:idx/%s,%s/json?use_decluttered=true',
  2955.                     $this->apiBaseUrl,
  2956.                     $startDate,
  2957.                     $endDate,
  2958.                     $interval,
  2959.                     $unit,
  2960.                     $interval,
  2961.                     $latitude,
  2962.                     $longitude
  2963.                 );
  2966.                 $client = new Client(['verify' => false]);
  2969.                 $response = $client->request('GET', $url, [
  2970.                     'auth' => [$this->username, $this->password],
  2971.                 ]);
  2973.                 $statusCode = $response->getStatusCode();
  2974.                 $data = json_decode($response->getBody(), true);
  2976.                 // Set the data to Redis cache
  2977.                 $this->redisCache->set($cacheKey, $data);
  2979.                 return $data;
  2980.             }
  2981.         } catch (GuzzleHttp\Exception\RequestException $e) {
  2982.             return throw new \Exception($e->getMessage());
  2983.         } catch (\Exception $e) {
  2984.             return throw new \Exception($e->getMessage());
  2985.         }
  2986.     }
  2988.     /**
  2989.      * Icing Potential
  2990.      *
  2991.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2992.      * @param string $startDate The start date for the forecast
  2993.      * @param string $interval gap between duration
  2994.      * @param string $duration The duration for the forecast (default: '24')
  2995.      * @param string $intervalType type of interval (default: 'hour')
  2996.      * @param string $format The format of the forecast data (default: 'json')
  2997.      * @return array The model forecast data
  2998.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2999.      */
  3000.     public function getIcingPotential(array $coordinates, string $startDate, string $duration = '24', $interval = '1', $level = '300hPa', $translator, string $format = "json")
  3001.     {
  3002.         try {
  3004.             // Validate the input parameters
  3005.             if (empty($coordinates)) {
  3006.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  3007.             }
  3009.             if (!is_array($coordinates) || count($coordinates) < 1) {
  3010.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  3011.             }
  3013.             $latitude = $coordinates[0][0] ?? null;
  3014.             $longitude = $coordinates[0][1] ?? null;
  3016.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  3017.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3018.             }
  3020.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  3021.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3022.             }
  3024.             if (empty($startDate)) {
  3025.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3026.             }
  3028.             if (!is_numeric($duration)) {
  3029.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  3030.             }
  3032.             if (!is_numeric($interval)) {
  3033.                 return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3034.             }
  3036.             if (!in_array($level, ['1000hPa', '975hPa', '950hPa', '925hPa', '900hPa', '875hPa', '850hPa', '825hPa', '800hPa', '775hPa', '750hPa', '700hPa', '650hPa', '600hPa', '550hPa', '500hPa', '450hPa', '400hPa', '350hPa', '300hPa'])) {
  3037.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  3038.             }
  3041.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3043.             // Create a Redis key for the cache            
  3044.             $cacheKey = sprintf('icing_potential_%s_%s', implode('_', array_map(function ($coordinate) {
  3045.                 return implode('_', $coordinate);
  3046.             }, $coordinates)), (($startDate) . $duration . $interval . $level));
  3049.             // Try to get the data from Redis cache
  3050.             $cachedData = $this->redisCache->get($cacheKey);
  3052.             if ($cachedData !== null) {
  3053.                 // Return the cached data if available
  3054.                 return $cachedData;
  3055.             }
  3057.             // If cache is empty, get the data from the API
  3058.             //https://api.meteomatics.com/2023-07-22T00:00:00ZP5D:PT1H/icing_potential_300hPa:idx,icing_potential_500hPa:idx,icing_potential_800hPa:idx/47.457625,8.555272/html
  3059.             $url = sprintf(
  3060.                 '%s/%sP%sD:PT%sH/icing_potential_%s:idx/%s,%s/json?use_decluttered=true',
  3061.                 $this->apiBaseUrl,
  3062.                 $startDate,
  3063.                 $duration,
  3064.                 $interval,
  3065.                 $level,
  3066.                 $latitude,
  3067.                 $longitude
  3068.             );
  3070.             $client = new Client(['verify' => false]);
  3073.             $response = $client->request('GET', $url, [
  3074.                 'auth' => [$this->username, $this->password],
  3075.             ]);
  3077.             $statusCode = $response->getStatusCode();
  3078.             $data = json_decode($response->getBody(), true);
  3080.             // Set the data to Redis cache
  3081.             $this->redisCache->set($cacheKey, $data);
  3083.             return $data;
  3084.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3085.             return throw new \Exception($e->getMessage());
  3086.         } catch (\Exception $e) {
  3087.             return throw new \Exception($e->getMessage());
  3088.         }
  3089.     }
  3091.     /**
  3092.      * Wind Gust
  3093.      *
  3094.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  3095.      * @param string $startDate The start date for the forecast
  3096.      * @param string $interval Gap between duration
  3097.      * @param string $duration The duration for the forecast (default: '24')
  3098.      * @param string $intervalType type of interval (default: 'hour')
  3099.      * @param string $format The format of the forecast data (default: 'json')
  3100.      * @return array The model forecast data
  3101.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3102.      */
  3103.     //https://api.meteomatics.com/2023-07-11T00:00:00ZP2D:PT3H/wind_dir_10m:d,wind_dir_700hPa:d/47.412164,9.340652/csv
  3104.     public function getWindGust(array $coordinates, string $startDate, string $duration = '24', string $interval = '1', $height = '100', $translator, string $format = "json")
  3105.     {
  3106.         try {
  3108.             // Validate the input parameters
  3109.             if (empty($coordinates)) {
  3110.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  3111.             }
  3113.             if (!is_array($coordinates) || count($coordinates) < 1) {
  3114.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  3115.             }
  3117.             $latitude = $coordinates[0][0] ?? null;
  3118.             $longitude = $coordinates[0][1] ?? null;
  3120.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  3121.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3122.             }
  3124.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  3125.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3126.             }
  3128.             if (empty($startDate)) {
  3129.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3130.             }
  3132.             if (!is_numeric($duration)) {
  3133.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  3134.             }
  3136.             if (!in_array($duration, ['1', '3', '6', '12', '24'])) {
  3137.                 return ["success" => false, "message" => $translator->trans("invalid_duration")];
  3138.             }
  3140.             if (!is_numeric($interval)) {
  3141.                 return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3142.             }
  3144.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3146.             // Create a Redis key for the cache            
  3147.             $cacheKey = sprintf('wind_gusts_%s_%s', implode('_', array_map(function ($coordinate) {
  3148.                 return implode('_', $coordinate);
  3149.             }, $coordinates)), (($startDate) . $duration . $interval));
  3152.             // Try to get the data from Redis cache
  3153.             $cachedData = $this->redisCache->get($cacheKey);
  3155.             if ($cachedData !== null) {
  3156.                 // Return the cached data if available
  3157.                 return $cachedData;
  3158.             }
  3160.             // If cache is empty, get the data from the API
  3161.             // https://api.meteomatics.com/2023-07-22T00:00:00ZP4D:PT3H/wind_speed_mean_100m_3h:ms,wind_gusts_100m_3h:ms/47.412164,9.340652/html
  3162.             $url = sprintf(
  3163.                 '%s/%sP%sD:PT%sH/wind_gusts_%s_%sh:ms/%s,%s/json?use_decluttered=true',
  3164.                 $this->apiBaseUrl,
  3165.                 $startDate,
  3166.                 $duration,
  3167.                 $interval,
  3168.                 $height,
  3169.                 $interval,
  3170.                 $latitude,
  3171.                 $longitude
  3172.             );
  3174.             $client = new Client(['verify' => false]);
  3176.             $response = $client->request('GET', $url, [
  3177.                 'auth' => [$this->username, $this->password],
  3178.             ]);
  3180.             $statusCode = $response->getStatusCode();
  3181.             $data = json_decode($response->getBody(), true);
  3183.             // Set the data to Redis cache
  3184.             $this->redisCache->set($cacheKey, $data);
  3186.             return $data;
  3187.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3188.             return throw new \Exception($e->getMessage());
  3189.         } catch (\Exception $e) {
  3190.             return throw new \Exception($e->getMessage());
  3191.         }
  3192.     }
  3194.     /**
  3195.      * Lightning Strikes
  3196.      *
  3197.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]    
  3198.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3199.      */
  3200.     public function getLightningStrikes(array $coordinates)
  3201.     {
  3202.         try {
  3204.             // Validate the input parameters
  3205.             if (empty($coordinates)) {
  3206.                 throw new \InvalidArgumentException('Invalid coordinates');
  3207.             }
  3210.             // Create a Redis key for the cache            
  3211.             $cacheKey = sprintf('lighting_strikes_%s', implode('_', array_map(function ($coordinate) {
  3212.                 return $coordinate;
  3213.             }, $coordinates)));
  3216.             // Try to get the data from Redis cache
  3217.             $cachedData = $this->redisCache->get($cacheKey);
  3219.             if ($cachedData !== null) {
  3220.                 // Return the cached data if available
  3221.                 // return $cachedData;
  3222.             }
  3224.             // If cache is empty, get the data from the API
  3225.             // https://api.meteomatics.com/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=lightnings&BBOX=5.77,45.74,10.65,47.89
  3227.             $url = sprintf(
  3228.                 '%s/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=lightnings&BBOX=%s&use_decluttered=true',
  3229.                 $this->apiBaseUrl,
  3230.                 implode(",", $coordinates)
  3231.             );
  3233.             $client = new Client(['verify' => false]);
  3235.             $response = $client->request('GET', $url, [
  3236.                 'auth' => [$this->username, $this->password],
  3237.             ]);
  3239.             $statusCode = $response->getStatusCode();
  3240.             $data = $response->getBody();
  3242.             // Set the data to Redis cache
  3243.             $this->redisCache->set($cacheKey, $data);
  3245.             return $data;
  3246.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3247.             return throw new \Exception($e->getMessage());
  3248.         } catch (\Exception $e) {
  3249.             return throw new \Exception($e->getMessage());
  3250.         }
  3251.     }
  3253.     /**
  3254.      * Fetches Turbulence data from the API or cache
  3255.      *
  3256.      * @param string $datetime The date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3257.      * @return mixed The Turbulence data if available, or an error response
  3258.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3259.      */
  3260.     public function getTurbulenceData(string $datetime)
  3261.     {
  3262.         try {
  3263.             // Validate the input parameter
  3264.             if (empty($datetime)) {
  3265.                 throw new \InvalidArgumentException('Invalid datetime');
  3266.             }
  3268.             $datetime = date('Y-m-d\TH:i:s.v\Z', (strtotime($datetime)));
  3270.             // Create a Redis key for the cache
  3271.             $cacheKey = sprintf('turbulence_%s', $datetime);
  3273.             // Try to get the data from Redis cache
  3274.             $cachedData = $this->redisCache->get($cacheKey);
  3276.             if ($cachedData !== null) {
  3277.                 // Return the cached data if available
  3278.                 //return $cachedData;
  3279.             }
  3282.             $client = new Client(['verify' => false]);
  3284.             // If cache is empty, get the data from the API           
  3285.             $url = sprintf(
  3286.                 '%s/%s/turbulence_cape:m23s/global:1,1/html_map?use_decluttered=true',
  3287.                 $this->apiBaseUrl,
  3288.                 $datetime
  3289.             );
  3291.             // Make an HTTP request to the API
  3292.             $response = $client->request('GET', $url, [
  3293.                 'auth' => [$this->username, $this->password],
  3294.             ]);
  3297.             $statusCode = $response->getStatusCode();
  3298.             $data = json_decode($response->getBody(), true);
  3300.             // Set the data to Redis cache
  3301.             $this->redisCache->set($cacheKey, $data);
  3303.             return $data;
  3304.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3305.             // Handle Guzzle HTTP request exceptions and create and return an error response            
  3306.             return throw new \Exception($e->getMessage());
  3307.         } catch (\Exception $e) {
  3308.             // Handle other exceptions and create and return an error response
  3309.             return throw new \Exception($e->getMessage());
  3310.         }
  3311.     }
  3313.     /**
  3314.      * Fetches SIGMET data from the API or cache
  3315.      *
  3316.      * @param string $datetime The date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3317.      * @return mixed The SIGMET data if available, or an error response
  3318.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3319.      */
  3320.     public function getSigmetData(string $datetime, $translator)
  3321.     {
  3322.         try {
  3323.             // Validate the input parameter
  3324.             if (empty($datetime)) {
  3325.                 return ["success" => false, "message" => $translator->trans("invalid_datetime")];
  3326.             }
  3328.             $datetime = date('Y-m-d\TH:i:s.v\Z', (strtotime($datetime)));
  3330.             // Create a Redis key for the cache
  3331.             $cacheKey = sprintf('sigmet_%s', $datetime);
  3333.             // Try to get the data from Redis cache
  3334.             $cachedData = $this->redisCache->get($cacheKey);
  3336.             if ($cachedData !== null) {
  3337.                 // Return the cached data if available
  3338.                 return $cachedData;
  3339.             }
  3341.             // If cache is empty, get the data from the API            
  3342.             $url = sprintf(
  3343.                 '%s/mvt/aviation_reports/sigmet:0/style.json?datetime=%s&use_decluttered=true',
  3344.                 $this->apiBaseUrl,
  3345.                 $datetime
  3346.             );
  3348.             $client = new Client(['verify' => false]);
  3350.             // Make an HTTP request to the API
  3351.             $response = $client->request('GET', $url, [
  3352.                 'auth' => [$this->username, $this->password],
  3353.             ]);
  3356.             $statusCode = $response->getStatusCode();
  3357.             $data = json_decode($response->getBody(), true);
  3359.             // Set the data to Redis cache
  3360.             $this->redisCache->set($cacheKey, $data);
  3362.             return $data;
  3363.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3364.             // Handle Guzzle HTTP request exceptions and create and return an error response
  3365.             return throw new \Exception($e->getMessage());
  3366.         } catch (\Exception $e) {
  3367.             // Handle other exceptions and create and return an error response
  3368.             return throw new \Exception($e->getMessage());
  3369.         }
  3370.     }
  3372.     /**
  3373.      * Fetches Geopotential Height data from the API or cache
  3374.      *
  3375.      * @param array $coordinates The coordinates value
  3376.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3377.      * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"     
  3378.      * @param float $level The level value
  3379.      * @param float $interval The interval value
  3380.      * @return mixed The Geopotential Height data if available, or an error response
  3381.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3382.      */
  3383.     public function getGeopotentialHeightData(array $coordinates, string $startDate, string $endDate, string $level, string $interval, $translator)
  3384.     {
  3385.         try {
  3387.             if ($coordinates) {
  3388.                 $latitude = $coordinates[0][0];
  3389.                 $longitude = $coordinates[0][1];
  3390.             }
  3392.             // Validate the input parameters
  3393.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3394.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3395.             }
  3396.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3397.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3398.             }
  3400.             if (empty($startDate) || empty($endDate)) {
  3401.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];;
  3402.             }
  3404.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3405.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3407.             if (!is_numeric($interval)) {
  3408.                 return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3409.             }
  3411.             if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  3412.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  3413.             }
  3416.             // Create a Redis key for the cache
  3417.             $cacheKey = sprintf('geopotential_height_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3419.             // Try to get the data from Redis cache
  3420.             $cachedData = $this->redisCache->get($cacheKey);
  3422.             if ($cachedData !== null) {
  3423.                 // Return the cached data if available
  3424.                 return $cachedData;
  3425.             }
  3427.             // If cache is empty, get the data from the API  
  3428.             //https://api.meteomatics.com/2023-07-23T00:00:00Z--2023-07-26T00:00:00Z:PT1H/geopotential_height_500hPa:m/46.5468,7.9826/html          
  3429.             $url = sprintf(
  3430.                 '%s/%s--%s:PT%sH/geopotential_height_%s:m/%s,%s/json?use_decluttered=true',
  3431.                 $this->apiBaseUrl,
  3432.                 $startDate,
  3433.                 $endDate,
  3434.                 $interval,
  3435.                 $level,
  3436.                 $latitude,
  3437.                 $longitude
  3438.             );
  3440.             $client = new Client(['verify' => false]);
  3442.             // Make an HTTP request to the API
  3443.             $response = $client->request('GET', $url, [
  3444.                 'auth' => [$this->username, $this->password],
  3445.             ]);
  3448.             $statusCode = $response->getStatusCode();
  3449.             $data = json_decode($response->getBody(), true);
  3451.             // Set the data to Redis cache
  3452.             $this->redisCache->set($cacheKey, $data);
  3454.             return $data;
  3455.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3456.             // Handle Guzzle HTTP request exceptions and create and return an error response
  3457.             return throw new \Exception($e->getMessage());
  3458.         } catch (\Exception $e) {
  3459.             // Handle other exceptions and create and return an error response
  3460.             return throw new \Exception($e->getMessage());
  3461.         }
  3462.     }
  3464.     /**
  3465.      * Pressure at Higher Altitudes data from the API or cache
  3466.      *
  3467.      * @param array $coordinates The coordinates value
  3468.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3469.      * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"     
  3470.      * @param float $level The level value
  3471.      * @param float $interval The interval value
  3472.      * @return mixed The Geopotential Height data if available, or an error response
  3473.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3474.      */
  3475.     public function getPressureData(array $coordinates, string $startDate, string $endDate, string $level, string $interval)
  3476.     {
  3477.         try {
  3479.             if ($coordinates) {
  3480.                 $latitude = $coordinates[0][0];
  3481.                 $longitude = $coordinates[0][1];
  3482.             }
  3484.             // Validate the input parameters
  3485.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3486.                 throw new \InvalidArgumentException('Invalid latitude');
  3487.             }
  3488.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3489.                 throw new \InvalidArgumentException('Invalid longitude');
  3490.             }
  3492.             if (empty($startDate) || empty($endDate)) {
  3493.                 throw new \InvalidArgumentException('Invalid dates');
  3494.             }
  3496.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3497.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3499.             if (!is_numeric($interval)) {
  3500.                 throw new \InvalidArgumentException('Interval should be numeric');
  3501.             }
  3503.             if ($level < 1 && $level > 20000) {
  3504.                 throw new \InvalidArgumentException('Invalid level it should be between 1 to 20000');
  3505.             }
  3507.             // Create a Redis key for the cache
  3508.             $cacheKey = sprintf('pressure_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3510.             // Try to get the data from Redis cache
  3511.             $cachedData = $this->redisCache->get($cacheKey);
  3513.             if ($cachedData !== null) {
  3514.                 // Return the cached data if available
  3515.                 return $cachedData;
  3516.             }
  3518.             // If cache is empty, get the data from the API  
  3519.             ///pressure_1000m:hPa/-16.489689,-68.119293/html          
  3520.             $url = sprintf(
  3521.                 '%s/%s--%s:PT%sH/pressure_%sm:hPa/%s,%s/json?use_decluttered=true',
  3522.                 $this->apiBaseUrl,
  3523.                 $startDate,
  3524.                 $endDate,
  3525.                 $interval,
  3526.                 $level,
  3527.                 $latitude,
  3528.                 $longitude
  3529.             );
  3531.             $client = new Client(['verify' => false]);
  3533.             // Make an HTTP request to the API
  3534.             $response = $client->request('GET', $url, [
  3535.                 'auth' => [$this->username, $this->password],
  3536.             ]);
  3539.             $statusCode = $response->getStatusCode();
  3540.             $data = json_decode($response->getBody(), true);
  3542.             // Set the data to Redis cache
  3543.             $this->redisCache->set($cacheKey, $data);
  3545.             return $data;
  3546.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3547.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  3548.             return throw new \Exception($e->getMessage());
  3549.         } catch (\Exception $e) {
  3550.             // Handle other exceptions and create and return an error response
  3551.             return throw new \Exception($e->getMessage());
  3552.         }
  3553.     }
  3556.     /**
  3557.      * Cloud Cover data from the API or cache
  3558.      *
  3559.      * @param array $coordinates The coordinates value
  3560.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3561.      * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"     
  3562.      * @param float $level The level value
  3563.      * @param float $interval The interval value
  3564.      * @return mixed The Geopotential Height data if available, or an error response
  3565.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3566.      */
  3567.     public function getCloudCover(array $coordinates, string $startDate, string $endDate, $translator)
  3568.     {
  3569.         try {
  3571.             if ($coordinates) {
  3572.                 $latitude = $coordinates[0][0];
  3573.                 $longitude = $coordinates[0][1];
  3574.             }
  3576.             // Validate the input parameters
  3577.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3578.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3579.             }
  3580.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3581.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3582.             }
  3584.             if (empty($startDate) || empty($endDate)) {
  3585.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3586.             }
  3588.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3589.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3591.             // Create a Redis key for the cache
  3592.             $cacheKey = sprintf('cloud_cover_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3594.             // Try to get the data from Redis cache
  3595.             $cachedData = $this->redisCache->get($cacheKey);
  3597.             if ($cachedData !== null) {
  3598.                 // Return the cached data if available
  3599.                 return $cachedData;
  3600.             }
  3602.             // If cache is empty, get the data from the API                
  3603.             $url = sprintf(
  3604.                 '%s/%s/effective_cloud_cover:octas/%s,%s/json?use_decluttered=true',
  3605.                 $this->apiBaseUrl,
  3606.                 $startDate,
  3607.                 $latitude,
  3608.                 $longitude
  3609.             );
  3611.             $client = new Client(['verify' => false]);
  3613.             // Make an HTTP request to the API
  3614.             $response = $client->request('GET', $url, [
  3615.                 'auth' => [$this->username, $this->password],
  3616.             ]);
  3619.             $statusCode = $response->getStatusCode();
  3620.             $data = json_decode($response->getBody(), true);
  3622.             // Set the data to Redis cache
  3623.             $this->redisCache->set($cacheKey, $data);
  3625.             return $data;
  3626.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3627.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  3628.             return throw new \Exception($e->getMessage());
  3629.         } catch (\Exception $e) {
  3630.             // Handle other exceptions and create and return an error response
  3631.             return throw new \Exception($e->getMessage());
  3632.         }
  3633.     }
  3635.     /**
  3636.      * Wind Speed vertical components data from the API or cache
  3637.      *
  3638.      * @param array $coordinates The coordinates value
  3639.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3640.      * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"     
  3641.      * @param int $level The day value
  3642.      * @param string $level The level value
  3643.      * @param string $unit The level value
  3644.      * @param intervalInMinutes $interval The interval value
  3645.      * @return mixed The Geopotential Height data if available, or an error response
  3646.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3647.      */
  3648.     public function getWindSpeedVerticalComponents(array $coordinates, string $startDate, int $day, int $intervalInMinutes, string $level, string $unit, $translator)
  3649.     {
  3650.         try {
  3652.             if ($coordinates) {
  3653.                 $latitude = $coordinates[0][0];
  3654.                 $longitude = $coordinates[0][1];
  3655.             }
  3657.             // Validate the input parameters
  3658.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3659.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3660.             }
  3661.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3662.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3663.             }
  3665.             if (empty($startDate)) {
  3666.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3667.             }
  3669.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3671.             if (!is_numeric($day)) {
  3672.                 return ["success" => false, "message" => $translator->trans("day_should_be_numeric")];
  3673.             }
  3675.             if (!is_numeric($intervalInMinutes)) {
  3676.                 return ["success" => false, "message" => $translator->trans("interval_in_minute_should_be_numeric")];
  3677.             }
  3679.             if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa'])) {
  3680.                 return ["success" => false, "message" => $translator->trans("invalid_level")];
  3681.             }
  3683.             // Create a Redis key for the cache
  3684.             $cacheKey = sprintf('wind_speed_vertical_%s_%s_%s_%s_%.6f_%.6f', $startDate, $day, $level, $unit, $latitude, $longitude);
  3686.             // Try to get the data from Redis cache
  3687.             $cachedData = $this->redisCache->get($cacheKey);
  3689.             if ($cachedData !== null) {
  3690.                 // Return the cached data if available
  3691.                 return $cachedData;
  3692.             }
  3695.             // If cache is empty, get the data from the API                
  3696.             $url = sprintf(
  3697.                 '%s/%sP%sD:PT%sM/wind_speed_w_%s:%s/%s,%s/json?use_decluttered=true',
  3698.                 $this->apiBaseUrl,
  3699.                 $startDate,
  3700.                 $day,
  3701.                 $intervalInMinutes,
  3702.                 $level,
  3703.                 $unit,
  3704.                 $latitude,
  3705.                 $longitude
  3706.             );
  3708.             $client = new Client(['verify' => false]);
  3710.             // Make an HTTP request to the API
  3711.             $response = $client->request('GET', $url, [
  3712.                 'auth' => [$this->username, $this->password],
  3713.             ]);
  3715.             $data = json_decode($response->getBody(), true);
  3717.             // Set the data to Redis cache
  3718.             $this->redisCache->set($cacheKey, $data);
  3720.             return $data;
  3721.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3722.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  3723.             return throw new \Exception($e->getMessage());
  3724.         } catch (\Exception $e) {
  3725.             // Handle other exceptions and create and return an error response
  3726.             return throw new \Exception($e->getMessage());
  3727.         }
  3728.     }
  3730.     /**
  3731.      * Wind Power data from the API or cache
  3732.      * @param array $coordinates The coordinates value    
  3733.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3734.      * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"       
  3735.      * @param int $intervalInMinutes The interval value
  3736.      * @param int $height The height value
  3737.      * @param float $unit The interval value
  3738.      * @return mixed The Geopotential Height data if available, or an error response
  3739.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3740.      */
  3741.     public function getWindPower(array $coordinates, string $startDate, string $endDate, int $height, int $intervalInMinutes, string $unit, string $turbine_id, $translator)
  3742.     {
  3743.         try {
  3745.             if ($coordinates) {
  3746.                 $latitude = $coordinates[0][0];
  3747.                 $longitude = $coordinates[0][1];
  3748.             }
  3750.             // Validate the input parameters
  3751.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3752.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3753.             }
  3754.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3755.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3756.             }
  3758.             if (empty($startDate)) {
  3759.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3760.             }
  3762.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3763.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3766.             if (!is_numeric($intervalInMinutes)) {
  3767.                 return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3768.             }
  3770.             if (!is_numeric($height)) {
  3771.                 return ["success" => false, "message" => $translator->trans("height_should_be_numeric")];
  3772.             }
  3774.             // Create a Redis key for the cache
  3775.             $cacheKey = sprintf('wind_power_%s_%s_%s_%s_%s', $startDate, $endDate, $height, $unit, $intervalInMinutes);
  3777.             // Try to get the data from Redis cache
  3778.             $cachedData = $this->redisCache->get($cacheKey);
  3780.             if ($cachedData !== null) {
  3781.                 // Return the cached data if available
  3782.                 return $cachedData;
  3783.             }
  3785.             // If cache is empty, get the data from the API                
  3786.             $url = sprintf(
  3787.                 '%s/%s--%s:PT%sM/wind_power_turbine_%s_hub_height_%sm:%s,wind_power_turbine_siemens_swt_2_3_93_2300_hub_height_%sm:%s,wind_power_turbine_enercon_e66_2000_hub_height_%sm:%s/%s,%s/json?use_decluttered=true',
  3788.                 $this->apiBaseUrl,
  3789.                 $startDate,
  3790.                 $endDate,
  3791.                 $intervalInMinutes,
  3792.                 $turbine_id,
  3793.                 $height,
  3794.                 $unit,
  3795.                 $height,
  3796.                 $unit,
  3797.                 $height,
  3798.                 $unit,
  3799.                 $latitude,
  3800.                 $longitude
  3801.             );
  3803.             $client = new Client(['verify' => false]);
  3805.             // Make an HTTP request to the API
  3806.             $response = $client->request('GET', $url, [
  3807.                 'auth' => [$this->username, $this->password],
  3808.             ]);
  3810.             $data = json_decode($response->getBody(), true);
  3812.             // Set the data to Redis cache
  3813.             $this->redisCache->set($cacheKey, $data);
  3815.             return $data;
  3816.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3817.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  3818.             return throw new \Exception($e->getMessage());
  3819.         } catch (\Exception $e) {
  3820.             // Handle other exceptions and create and return an error response
  3821.             return throw new \Exception($e->getMessage());
  3822.         }
  3823.     }
  3825.     /**
  3826.      * Radiation data from the API or cache
  3827.      * @param array $coordinates The coordinates value    
  3828.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"           
  3829.      * @param int $intervalInHours The interval value
  3830.      * @param int $day The day value
  3831.      * @param string $typeOfRadiation should be one of these "clear_sky_rad","diffuse_rad","direct_rad","global_rad"
  3832.      * @return mixed The Geopotential Height data if available, or an error response
  3833.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3834.      */
  3835.     public function getRadiation(array $coordinates, string $startDate, int $day, int $intervalInHours, string $typeOfRadiation, $translator)
  3836.     {
  3837.         try {
  3839.             if ($coordinates) {
  3840.                 $latitude = $coordinates[0][0];
  3841.                 $longitude = $coordinates[0][1];
  3842.             }
  3844.             // Validate the input parameters
  3845.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3846.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3847.             }
  3848.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3849.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3850.             }
  3852.             if (empty($startDate)) {
  3853.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3854.             }
  3855.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3858.             if (!is_numeric($intervalInHours)) {
  3859.                 return ["success" => false, "message" => $translator->trans("interval_in_hour_should_be_numeric")];
  3860.             }
  3862.             if (!is_numeric($day)) {
  3863.                 return ["success" => false, "message" => $translator->trans("day_should_be_numeric")];
  3864.             }
  3866.             if (!in_array($typeOfRadiation, ["clear_sky_rad", "diffuse_rad", "direct_rad", "global_rad"])) {
  3867.                 // throw new \InvalidArgumentException('Radiation type should be one of these "clear_sky_rad","diffuse_rad","direct_rad","global_rad"');
  3868.                 return ["success" => false, "message" => $translator->trans("Radiation_should_be_type:'clear_sky_rad','diffuse_rad','direct_rad','global_rad'")];
  3869.             }
  3871.             // Create a Redis key for the cache
  3872.             $cacheKey = sprintf('radiation_%s_%s_%s_%s_%s_%s', $startDate, $day, $intervalInHours, $typeOfRadiation, $latitude, $longitude);
  3874.             // Try to get the data from Redis cache
  3875.             $cachedData = $this->redisCache->get($cacheKey);
  3877.             if ($cachedData !== null) {
  3878.                 // Return the cached data if available
  3879.                 return $cachedData;
  3880.             }
  3882.             // If cache is empty, get the data from the API                
  3883.             $url = sprintf(
  3884.                 '%s/%sP%sD:PT%sH/%s:W/%s,%s/json?use_decluttered=true',
  3885.                 $this->apiBaseUrl,
  3886.                 $startDate,
  3887.                 $day,
  3888.                 $intervalInHours,
  3889.                 $typeOfRadiation,
  3890.                 $latitude,
  3891.                 $longitude
  3892.             );
  3894.             $client = new Client(['verify' => false]);
  3896.             // Make an HTTP request to the API
  3897.             $response = $client->request('GET', $url, [
  3898.                 'auth' => [$this->username, $this->password],
  3899.             ]);
  3901.             $data = json_decode($response->getBody(), true);
  3903.             // Set the data to Redis cache
  3904.             $this->redisCache->set($cacheKey, $data);
  3906.             return $data;
  3907.         } catch (GuzzleHttp\Exception\RequestException $e) {
  3908.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  3909.             return throw new \Exception($e->getMessage());
  3910.         } catch (\Exception $e) {
  3911.             // Handle other exceptions and create and return an error response
  3912.             return throw new \Exception($e->getMessage());
  3913.         }
  3914.     }
  3916.     /**
  3917.      * Solar Power data from the API or cache
  3918.      * @param array $coordinates The coordinates value    
  3919.      * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ" 
  3920.      * @param string $endDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"           
  3921.      * @param int $intervalInHours The interval value
  3922.      * @param int $hour The hour value
  3923.      * @param string $unit The unit value
  3924.      * @param string $specification would be like this "installed_capacity_<capacity>"
  3925.      * @return mixed The Geopotential Height data if available, or an error response
  3926.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3927.      */
  3928.     public function getSolarPower(array $coordinates, string $startDate, string $endDate, int $intervalInHours, string $hour, string $unit, string $specification, $translator)
  3929.     {
  3930.         try {
  3932.             if ($coordinates) {
  3933.                 $latitude = $coordinates[0][0];
  3934.                 $longitude = $coordinates[0][1];
  3935.             }
  3937.             // Validate the input parameters
  3938.             if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3939.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3940.             }
  3941.             if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3942.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3943.             }
  3945.             if (empty($startDate)) {
  3946.                 return ["success" => false, "message" => $translator->trans("invalid_start_date")];
  3947.             }
  3949.             if (empty($endDate)) {
  3950.                 return ["success" => false, "message" => $translator->trans("invalid_end_date")];
  3951.             }
  3953.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3954.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3957.             if (!is_numeric($intervalInHours)) {
  3958.                 return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];;
  3959.             }
  3961.             if (!is_numeric($hour)) {
  3962.                 return ["success" => false, "message" => $translator->trans("hours_should_be_numeric")];
  3963.             }
  3966.             // Create a Redis key for the cache
  3967.             $cacheKey = sprintf('solar_power_%s_%s_%s_%s_%s_%s_%s', $specification, $startDate, $endDate, $unit, $hour, $latitude, $longitude);
  3969.             // Try to get the data from Redis cache
  3970.             $cachedData = $this->redisCache->get($cacheKey);
  3972.             if ($cachedData !== null) {
  3973.                 // Return the cached data if available
  3974.                 return $cachedData;
  3975.             }
  3977.             // If cache is empty, get the data from the API                
  3978.             $url = sprintf(
  3979.                 '%s/%s--%s:PT%sH/solar_power_%s:%s/%s,%s/json?use_decluttered=true',
  3980.                 $this->apiBaseUrl,
  3981.                 $startDate,
  3982.                 $endDate,
  3983.                 $hour,
  3984.                 $specification,
  3985.                 $unit,
  3986.                 $latitude,
  3987.                 $longitude
  3988.             );
  3989.             // p_r($url);
  3990.             // exit;
  3991.             $client = new Client(['verify' => false]);
  3993.             // Make an HTTP request to the API
  3994.             $response = $client->request('GET', $url, [
  3995.                 'auth' => [$this->username, $this->password],
  3996.             ]);
  3998.             $data = json_decode($response->getBody(), true);
  4000.             // Set the data to Redis cache
  4001.             $this->redisCache->set($cacheKey, $data);
  4003.             return $data;
  4004.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4005.             // Handle Guzzle HTTP request exceptions and create and return an error response           
  4006.             return throw new \Exception($e->getMessage());
  4007.         } catch (\Exception $e) {
  4008.             // Handle other exceptions and create and return an error response
  4009.             return throw new \Exception($e->getMessage());
  4010.         }
  4011.     }
  4013.     /**
  4014.      * Rainfall
  4015.      *
  4016.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4017.      * @param string $startDate The start date for the forecast
  4018.      * @param string $endDate The end date for the forecast
  4019.      * @param string $duration The duration for the forecast (default: '24')
  4020.      * @param string $intervalType type of interval (default: 'hour')
  4021.      * @param string $format The format of the forecast data (default: 'json')
  4022.      * @return array The model forecast data
  4023.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4024.      */
  4025.     public function getRainfall(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4026.     {
  4027.         try {
  4029.             // Validate the input parameters
  4030.             if (empty($coordinates)) {
  4031.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4032.             }
  4034.             if (!is_array($coordinates) || count($coordinates) < 1) {
  4035.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4036.             }
  4038.             $latitude = $coordinates[0][0] ?? null;
  4039.             $longitude = $coordinates[0][1] ?? null;
  4041.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4042.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4043.             }
  4045.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4046.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4047.             }
  4049.             if (empty($startDate) || empty($endDate)) {
  4050.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4051.             }
  4053.             if (!is_numeric($duration)) {
  4054.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4055.             }
  4058.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4059.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4061.             // Create a Redis key for the cache            
  4062.             $cacheKey = sprintf('rainfall_%s_%s', implode('_', array_map(function ($coordinate) {
  4063.                 return implode('_', $coordinate);
  4064.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4067.             // Try to get the data from Redis cache
  4068.             $cachedData = $this->redisCache->get($cacheKey);
  4070.             if ($cachedData !== null) {
  4071.                 // Return the cached data if available
  4072.                 return $cachedData;
  4073.             }
  4075.             // If cache is empty, get the data from the API
  4076.             $url = sprintf(
  4077.                 '%s/%s--%s:PT%sM/is_rain_%smin:idx/%s,%s/json?use_decluttered=true',
  4078.                 $this->apiBaseUrl,
  4079.                 $startDate,
  4080.                 $endDate,
  4081.                 $duration,
  4082.                 $duration,
  4083.                 $latitude,
  4084.                 $longitude
  4085.             );
  4087.             $client = new Client(['verify' => false]);
  4090.             $response = $client->request('GET', $url, [
  4091.                 'auth' => [$this->username, $this->password],
  4092.             ]);
  4094.             $statusCode = $response->getStatusCode();
  4095.             $data = json_decode($response->getBody(), true);
  4097.             // Set the data to Redis cache
  4098.             $this->redisCache->set($cacheKey, $data);
  4100.             return $data;
  4101.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4102.             return throw new \Exception($e->getMessage());
  4103.         } catch (\Exception $e) {
  4104.             return throw new \Exception($e->getMessage());
  4105.         }
  4106.     }
  4108.     /**
  4109.      * Dew Point
  4110.      *
  4111.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4112.      * @param string $startDate The start date for the forecast
  4113.      * @param string $endDate The end date for the forecast
  4114.      * @param string $duration The duration for the forecast (default: '24')
  4115.      * @param string $intervalType type of interval (default: 'hour')
  4116.      * @param string $format The format of the forecast data (default: 'json')
  4117.      * @return array The model forecast data
  4118.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4119.      */
  4120.     public function getDewPoint(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4121.     {
  4122.         try {
  4124.             // Validate the input parameters
  4125.             if (empty($coordinates)) {
  4126.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4127.             }
  4129.             if (!is_array($coordinates) || count($coordinates) < 1) {
  4130.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4131.             }
  4133.             $latitude = $coordinates[0][0] ?? null;
  4134.             $longitude = $coordinates[0][1] ?? null;
  4136.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4137.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4138.             }
  4140.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4141.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4142.             }
  4144.             if (empty($startDate) || empty($endDate)) {
  4145.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4146.             }
  4148.             if (!is_numeric($duration)) {
  4149.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4150.             }
  4153.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4154.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4156.             // Create a Redis key for the cache            
  4157.             $cacheKey = sprintf('dew_point_%s_%s', implode('_', array_map(function ($coordinate) {
  4158.                 return implode('_', $coordinate);
  4159.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4162.             // Try to get the data from Redis cache
  4163.             $cachedData = $this->redisCache->get($cacheKey);
  4165.             if ($cachedData !== null) {
  4166.                 // Return the cached data if available
  4167.                 return $cachedData;
  4168.             }
  4170.             // If cache is empty, get the data from the API
  4171.             $url = sprintf(
  4172.                 '%s/%s--%s:PT%sH/dew_point_2m:C/%s,%s/json?use_decluttered=true',
  4173.                 $this->apiBaseUrl,
  4174.                 $startDate,
  4175.                 $endDate,
  4176.                 $duration,
  4177.                 $latitude,
  4178.                 $longitude
  4179.             );
  4181.             $client = new Client(['verify' => false]);
  4184.             $response = $client->request('GET', $url, [
  4185.                 'auth' => [$this->username, $this->password],
  4186.             ]);
  4188.             $statusCode = $response->getStatusCode();
  4189.             $data = json_decode($response->getBody(), true);
  4191.             // Set the data to Redis cache
  4192.             $this->redisCache->set($cacheKey, $data);
  4194.             return $data;
  4195.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4196.             return throw new \Exception($e->getMessage());
  4197.         } catch (\Exception $e) {
  4198.             return throw new \Exception($e->getMessage());
  4199.         }
  4200.     }
  4202.     /**
  4203.      * Wms
  4204.      *     
  4205.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4206.      */
  4207.     public function getWms($params)
  4208.     {
  4209.         try {
  4211.             // If cache is empty, get the data from the API
  4212.             $url = sprintf(
  4213.                 '%s/wms?%s&use_decluttered=true',
  4214.                 $this->apiBaseUrl,
  4215.                 $params['param']
  4216.             );
  4218.             $client = new Client(['verify' => false]);
  4219.             $response = $client->request('GET', $url, [
  4220.                 'auth' => [$this->username, $this->password],
  4221.             ]);
  4223.             return $response->getBody();
  4224.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4225.             return throw new \Exception($e->getMessage());
  4226.         } catch (\Exception $e) {
  4227.             return throw new \Exception($e->getMessage());
  4228.         }
  4229.     }
  4231.     /**
  4232.      * Compute Web Mercator bbox for a tile (z/x/y) and fetch WMS tile.
  4233.      */
  4234.     public function getWmsTileByXYZ(
  4235.         string $layers,
  4236.         string $time,
  4237.         int $z,
  4238.         int $x,
  4239.         int $y,
  4240.         string $format = 'image/webp',
  4241.         ?string $model = null,
  4242.         string $version = '1.3.0',
  4243.         string $crs = 'EPSG:3857',
  4244.         int $width = 256,
  4245.         int $height = 256,
  4246.         string $transparent = 'true',
  4247.         string $styles = ''
  4248.     ) {
  4249.         // Web Mercator constants
  4250.         $earthRadius = 6378137;
  4251.         $circumference = 2 * pi() * $earthRadius;
  4252.         $resolution = ($circumference / 256) / pow(2, $z);
  4254.         $minX = ($x * 256) * $resolution - $circumference / 2.0;
  4255.         $minY = ($y * 256) * $resolution - $circumference / 2.0;
  4256.         $maxX = (($x + 1) * 256) * $resolution - $circumference / 2.0;
  4257.         $maxY = (($y + 1) * 256) * $resolution - $circumference / 2.0;
  4259.         $bbox = $minX . ',' . $minY . ',' . $maxX . ',' . $maxY;
  4261.         $queryParams = [
  4262.             'service' => 'WMS',
  4263.             'request' => 'GetMap',
  4264.             'layers' => $layers,
  4265.             'styles' => $styles,
  4266.             'format' => $format,
  4267.             'transparent' => $transparent,
  4268.             'version' => $version,
  4269.             'time' => $time,
  4270.             'width' => $width,
  4271.             'height' => $height,
  4272.             'crs' => $crs,
  4273.             'bbox' => $bbox,
  4274.         ];
  4275.         if (!empty($model)) {
  4276.             $queryParams['model'] = $model;
  4277.         }
  4279.         $paramString = http_build_query($queryParams, '', '&', PHP_QUERY_RFC3986);
  4280.         return $this->getWms(['param' => $paramString]);
  4281.     }
  4283.     /**
  4284.      * Wind
  4285.      *
  4286.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4287.      * @param string $startDate The start date for the forecast
  4288.      * @param string $endDate The end date for the forecast
  4289.      * @param string $duration The duration for the forecast (default: '24')
  4290.      * @param string $intervalType type of interval (default: 'hour')
  4291.      * @param string $format The format of the forecast data (default: 'json')
  4292.      * @return array The model forecast data
  4293.      * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4294.      */
  4295.     public function getWind(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4296.     {
  4297.         try {
  4299.             // Validate the input parameters
  4300.             if (empty($coordinates)) {
  4301.                 return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4302.             }
  4304.             if (!is_array($coordinates) || count($coordinates) < 1) {
  4305.                 return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4306.             }
  4308.             $latitude = $coordinates[0][0] ?? null;
  4309.             $longitude = $coordinates[0][1] ?? null;
  4311.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4312.                 return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4313.             }
  4315.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4316.                 return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4317.             }
  4319.             if (empty($startDate) || empty($endDate)) {
  4320.                 return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4321.             }
  4323.             if (!is_numeric($duration)) {
  4324.                 return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4325.             }
  4328.             $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4329.             $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4331.             // Create a Redis key for the cache            
  4332.             $cacheKey = sprintf('wind_%s_%s', implode('_', array_map(function ($coordinate) {
  4333.                 return implode('_', $coordinate);
  4334.             }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4337.             // Try to get the data from Redis cache
  4338.             $cachedData = $this->redisCache->get($cacheKey);
  4340.             if ($cachedData !== null) {
  4341.                 // Return the cached data if available
  4342.                 return $cachedData;
  4343.             }
  4345.             // If cache is empty, get the data from the API
  4346.             $url = sprintf(
  4347.                 '%s/%s--%s:PT%sH/wind_speed_u_10m:ms,wind_speed_v_10m:ms/%s,%s/json?use_decluttered=true',
  4348.                 $this->apiBaseUrl,
  4349.                 $startDate,
  4350.                 $endDate,
  4351.                 $duration,
  4352.                 $latitude,
  4353.                 $longitude
  4354.             );
  4356.             $client = new Client(['verify' => false]);
  4359.             $response = $client->request('GET', $url, [
  4360.                 'auth' => [$this->username, $this->password],
  4361.             ]);
  4363.             $statusCode = $response->getStatusCode();
  4364.             $data = json_decode($response->getBody(), true);
  4366.             // Set the data to Redis cache
  4367.             $this->redisCache->set($cacheKey, $data);
  4369.             return $data;
  4370.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4371.             return throw new \Exception($e->getMessage());
  4372.         } catch (\Exception $e) {
  4373.             return throw new \Exception($e->getMessage());
  4374.         }
  4375.     }
  4377.     /**
  4378.      * Wind by location
  4379.      *    
  4380.      * @param string $time The type of data time (e.g., '2023-09-01')
  4381.      * @param string $location The latitude and longitude of location
  4382.      * @param string $format return type of json
  4383.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  4384.      */
  4385.     public function getWindByLocation(
  4386.         string $time,
  4387.         string $location,
  4388.         string $format = 'json'
  4389.     ) {
  4391.         if (!is_string($time)) {
  4392.             throw new \InvalidArgumentException('Invalid data type for $time. Expected string.');
  4393.         }
  4394.         if (!is_string($location)) {
  4395.             throw new \InvalidArgumentException('Invalid data type for $location. Expected string.');
  4396.         }
  4397.         if (!is_string($format)) {
  4398.             throw new \InvalidArgumentException('Invalid data type for $format. Expected string.');
  4399.         }
  4401.         $cacheKey = sprintf('wind_location_%s_%s', $time, $location);
  4403.         // Try to get the data from Redis cache
  4404.         $cachedData = $this->redisCache->get($cacheKey);
  4406.         if ($cachedData !== null) {
  4407.             // Return the cached data if available
  4408.             return $cachedData;
  4409.         }
  4412.         try {
  4413.             // If cache is empty, get the data from the API
  4414.             $client = new Client(['verify' => false]);
  4415.             $url = sprintf(
  4416.                 '%s/%s/wind_speed_u_10m:ms,wind_speed_v_10m:ms/%s/%s?use_decluttered=true',
  4417.                 $this->apiBaseUrl,
  4418.                 $time,
  4419.                 $location,
  4420.                 $format
  4421.             );
  4422.             $response = $client->request('GET', $url, [
  4423.                 'auth' => [$this->username, $this->password],
  4424.             ]);
  4425.             $data = json_decode($response->getBody(), true);
  4427.             // Set the data to Redis cache
  4428.             $this->redisCache->set($cacheKey, $data);
  4430.             return $data;
  4431.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4432.             return throw new \Exception($e->getMessage());
  4433.         } catch (\Exception $e) {
  4434.             return throw new \Exception($e->getMessage());
  4435.         }
  4436.     }
  4438.     /**
  4439.      * Water Temperature
  4440.      *    
  4441.      * @param string $query The type of data request (e.g., 't_sea_sfc:ms')
  4442.      * @param string $format return type of json
  4443.      * @param string $date The type of data date (e.g., '2023-09-01')
  4444.      * @param array $coordinates The latitude and longitude of location in array
  4445.      * @param string $dimensions type of data (e.g., '500x300')
  4446.      * @param string $modal type of data (e.g., 'noaa-hycom', 'ecmwf-cmems', 'noaa-hycom')
  4447.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  4448.      */
  4449.     public function getWaterTempereture(
  4450.         string $query,
  4451.         array $coordinates,
  4452.         string $dimensions,
  4453.         string $format,
  4454.         string $date,
  4455.         string $modal
  4456.     ) {
  4458.         try {
  4460.             if (empty($query)) {
  4461.                 throw new \InvalidArgumentException('Invalid query');
  4462.             }
  4464.             if (empty($date)) {
  4465.                 throw new \InvalidArgumentException('Invalid date');
  4466.             }
  4467.             $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4470.             foreach ($coordinates as $coordinate) {
  4471.                 if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4472.                     throw new \InvalidArgumentException('Invalid coordinates');
  4473.                 }
  4474.             }
  4476.             $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4478.             $cacheKey = \App\Lib\Utility::generateKey($query,  $coordinates,  $dimensions,  $date,  $format, $modal);
  4480.             // Try to get the data from Redis cache
  4481.             $cachedData = $this->redisCache->get($cacheKey);
  4483.             if ($cachedData !== null) {
  4484.                 // Return the cached data if available
  4485.                 return $cachedData;
  4486.             }
  4490.             // If cache is empty, get the data from the API
  4491.             $client = new Client(['verify' => false]);
  4492.             $url = sprintf(
  4493.                 '%s/%s/%s/%s:%s/%s?%s&use_decluttered=true',
  4494.                 $this->apiBaseUrl,
  4495.                 $date,
  4496.                 $query,
  4497.                 $coordinateString,
  4498.                 $dimensions,
  4499.                 $format,
  4500.                 $modal
  4501.             );
  4503.             $response = $client->request('GET', $url, [
  4504.                 'auth' => [$this->username, $this->password],
  4505.             ]);
  4507.             if ($format == "json") {
  4508.                 $data = json_decode($response->getBody(), true);
  4509.             } else {
  4510.                 $data = $response->getBody();
  4511.             }
  4514.             // Set the data to Redis cache
  4515.             $this->redisCache->set($cacheKey, $data);
  4517.             return $data;
  4518.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4519.             return throw new \Exception($e->getMessage());
  4520.         } catch (\Exception $e) {
  4521.             return throw new \Exception($e->getMessage());
  4522.         }
  4523.     }
  4525.     /**
  4526.      * Ocean Current
  4527.      *    
  4528.      * @param string $query The type of data request (e.g., 'ocean_current_speed_2m:ms')
  4529.      * @param string $format return type of json
  4530.      * @param string $date The type of data date (e.g., '2023-09-01')
  4531.      * @param array $coordinates The latitude and longitude of location in array
  4532.      * @param string $dimensions type of data (e.g., '500x300')
  4533.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  4534.      */
  4535.     public function getOceanCurrent(
  4536.         string $query,
  4537.         array $coordinates,
  4538.         string $dimensions,
  4539.         string $format,
  4540.         string $date
  4541.     ) {
  4542.         try {
  4544.             if (empty($query)) {
  4545.                 throw new \InvalidArgumentException('Invalid query');
  4546.             }
  4548.             if (empty($date)) {
  4549.                 throw new \InvalidArgumentException('Invalid dates');
  4550.             }
  4551.             $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4554.             foreach ($coordinates as $coordinate) {
  4555.                 if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4556.                     throw new \InvalidArgumentException('Invalid coordinates');
  4557.                 }
  4558.             }
  4560.             $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4562.             $cacheKey = \App\Lib\Utility::generateKey($query,  $coordinates,  $dimensions,  $date,  $format);
  4564.             // Try to get the data from Redis cache
  4565.             $cachedData = $this->redisCache->get($cacheKey);
  4567.             if ($cachedData !== null) {
  4568.                 // Return the cached data if available
  4569.                 return $cachedData;
  4570.             }
  4574.             // If cache is empty, get the data from the API
  4575.             $client = new Client(['verify' => false]);
  4576.             $url = sprintf(
  4577.                 '%s/%s/%s/%s:%s/%s?use_decluttered=true',
  4578.                 $this->apiBaseUrl,
  4579.                 $date,
  4580.                 $query,
  4581.                 $coordinateString,
  4582.                 $dimensions,
  4583.                 $format
  4584.             );
  4586.             $response = $client->request('GET', $url, [
  4587.                 'auth' => [$this->username, $this->password],
  4588.             ]);
  4590.             if ($format == "json") {
  4591.                 $data = json_decode($response->getBody(), true);
  4592.             } else {
  4593.                 $data = $response->getBody();
  4594.             }
  4597.             // Set the data to Redis cache
  4598.             $this->redisCache->set($cacheKey, $data);
  4600.             return $data;
  4601.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4602.             return throw new \Exception($e->getMessage());
  4603.         } catch (\Exception $e) {
  4604.             return throw new \Exception($e->getMessage());
  4605.         }
  4606.     }
  4608.     /**
  4609.      * Oceanic Tides
  4610.      *    
  4611.      * @param string $query The type of data request (e.g., 'tidal_amplitude:cm')
  4612.      * @param string $format return type of json
  4613.      * @param string $date The type of data date (e.g., '2023-09-01')
  4614.      * @param array $latitude The latitude of location
  4615.      * @param array $longitude The longitude of location
  4616.      * @param string $dimensions type of data (e.g., '500x300')
  4617.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  4618.      */
  4619.     public function getOceanicTides(
  4620.         string $query,
  4621.         string $latitude,
  4622.         string $longitude,
  4623.         string $date,
  4624.         string $format,
  4625.         string $resolution,
  4626.         string $model
  4627.     ) {
  4630.         try {
  4632.             if (empty($query)) {
  4633.                 throw new \InvalidArgumentException('Invalid query');
  4634.             }
  4636.             if (empty($date)) {
  4637.                 throw new \InvalidArgumentException('Invalid dates');
  4638.             }
  4640.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4641.                 throw new \InvalidArgumentException('Invalid latitude');
  4642.             }
  4644.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4645.                 throw new \InvalidArgumentException('Invalid longitude');
  4646.             }
  4648.             $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4651.             $cacheKey = \App\Lib\Utility::generateKey($query,  $latitude,  $longitude,  $date,  $format, $resolution, $model);
  4653.             // Try to get the data from Redis cache
  4654.             $cachedData = $this->redisCache->get($cacheKey);
  4656.             if ($cachedData !== null) {
  4657.                 // Return the cached data if available
  4658.                 return $cachedData;
  4659.             }
  4663.             // If cache is empty, get the data from the API
  4664.             $client = new Client(['verify' => false]);
  4665.             $url = sprintf(
  4666.                 '%s/%s%s/%s/%s,%s/%s?%s&use_decluttered=true',
  4667.                 $this->apiBaseUrl,
  4668.                 $date,
  4669.                 $resolution,
  4670.                 $query,
  4671.                 $latitude,
  4672.                 $longitude,
  4673.                 $format,
  4674.                 $model
  4676.             );
  4678.             $response = $client->request('GET', $url, [
  4679.                 'auth' => [$this->username, $this->password],
  4680.             ]);
  4682.             if ($format == "json") {
  4683.                 $data = json_decode($response->getBody(), true);
  4684.             } else {
  4685.                 $data = $response->getBody();
  4686.             }
  4689.             // Set the data to Redis cache
  4690.             $this->redisCache->set($cacheKey, $data);
  4692.             return $data;
  4693.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4694.             return throw new \Exception($e->getMessage());
  4695.         } catch (\Exception $e) {
  4696.             return throw new \Exception($e->getMessage());
  4697.         }
  4698.     }
  4700.     /**
  4701.      * Drought Index
  4702.      *    
  4703.      * @param string $query The type of data request (e.g., 'drought_index:idx/Asia')
  4704.      * @param string $format return type of json or html_map
  4705.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  4706.      * @param string $longitude The longitude of location
  4707.      * @param string $latitude The latitude of location
  4708.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  4709.      */
  4710.     public function getDroughtIndex(
  4711.         string $query,
  4712.         string $latitude,
  4713.         string $longitude,
  4714.         string $date,
  4715.         string $format,
  4717.     ) {
  4718.         try {
  4720.             if (empty($query)) {
  4721.                 throw new \InvalidArgumentException('Invalid query');
  4722.             }
  4724.             if (empty($date)) {
  4725.                 throw new \InvalidArgumentException('Invalid dates');
  4726.             }
  4728.             if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4729.                 throw new \InvalidArgumentException('Invalid latitude');
  4730.             }
  4732.             if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4733.                 throw new \InvalidArgumentException('Invalid longitude');
  4734.             }
  4738.             $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4742.             $cacheKey = \App\Lib\Utility::generateKey($query,  $latitude,  $longitude,  $date,  $format);
  4744.             // Try to get the data from Redis cache
  4745.             $cachedData = $this->redisCache->get($cacheKey);
  4747.             if ($cachedData !== null) {
  4748.                 // Return the cached data if available
  4749.                 return $cachedData;
  4750.             }
  4754.             // If cache is empty, get the data from the API
  4755.             $client = new Client(['verify' => false]);
  4756.             $url = sprintf(
  4757.                 '%s/%s/%s:%s,%s/%s?use_decluttered=true',
  4758.                 $this->apiBaseUrl,
  4759.                 $date,
  4760.                 $query,
  4761.                 $latitude,
  4762.                 $longitude,
  4763.                 $format
  4765.             );
  4767.             $response = $client->request('GET', $url, [
  4768.                 'auth' => [$this->username, $this->password],
  4769.             ]);
  4771.             if ($format == "json") {
  4772.                 $data = json_decode($response->getBody(), true);
  4773.             } else {
  4774.                 $data = $response->getBody();
  4775.             }
  4778.             // Set the data to Redis cache
  4779.             $this->redisCache->set($cacheKey, $data);
  4781.             return $data;
  4782.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4783.             return throw new \Exception($e->getMessage());
  4784.         } catch (\Exception $e) {
  4785.             return throw new \Exception($e->getMessage());
  4786.         }
  4787.     }
  4790.     /**
  4791.      * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  4792.      *
  4793.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4794.      * @param string $hourly The hour for which forecast is required in 24-hour format
  4795.      * @return array The hourly weather forecast data in JSON format
  4796.      */
  4797.     public function getHourlyForecastWithoutSymbols(array $coordinates, string $startDate, string $endDate, int $hour, string $model)
  4798.     {
  4800.         try {
  4802.             if (count($coordinates) > 1) {
  4804.                 // Validate the input parameters
  4805.                 foreach ($coordinates as $coordinate) {
  4806.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4807.                         throw new \InvalidArgumentException('Invalid coordinates');
  4808.                     }
  4809.                 }
  4811.                 if (empty($startDate) || empty($endDate)) {
  4812.                     throw new \InvalidArgumentException('Invalid dates');
  4813.                 }
  4815.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4816.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4818.                 // Create a Redis key for the cache
  4819.                 $cacheKey = sprintf('cn_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  4820.                     return implode('_', $coordinate);
  4821.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, $hour);
  4824.                 // Try to get the data from Redis cache
  4825.                 $cachedData = $this->redisCache->get($cacheKey);
  4828.                 if ($cachedData !== null) {
  4829.                     // Return the cached data if available
  4830.                     return $cachedData;
  4831.                 }
  4834.                 // If cache is empty, get the data from the API
  4835.                 $client = new Client(['verify' => false]);
  4837.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4838.                 $url1 = sprintf(
  4839.                     '%s/%s--%s:PT%sH/t_2m:C,wind_speed_10m:kmh,wind_dir_mean_100m_2h:d,prob_precip_2h:p,precip_2h:mm/%+%/json?model=' . $model . '&use_decluttered=true',
  4840.                     $this->apiBaseUrl,
  4841.                     $startDate,
  4842.                     $endDate,
  4843.                     $hour,
  4844.                     $coordinateString,
  4845.                     $coordinateString
  4846.                 );
  4847.             } else {
  4849.                 if ($coordinates) {
  4850.                     $latitude = $coordinates[0][0];
  4851.                     $longitude = $coordinates[0][1];
  4852.                 }
  4854.                 // Validate the input parameters
  4855.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  4856.                     throw new \InvalidArgumentException('Invalid latitude');
  4857.                 }
  4858.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  4859.                     throw new \InvalidArgumentException('Invalid longitude');
  4860.                 }
  4862.                 if (empty($startDate) || empty($endDate)) {
  4863.                     throw new \InvalidArgumentException('Invalid dates');
  4864.                 }
  4866.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4867.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4869.                 // Create a Redis key for the cache            
  4870.                 $cacheKey = sprintf('cn_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  4871.                     return implode('_', $coordinate);
  4872.                 }, $coordinates)), ($startDate . '-' . $endDate) . $model, $hour);
  4874.                 // Try to get the data from Redis cache
  4875.                 $cachedData = $this->redisCache->get($cacheKey);
  4877.                 if ($cachedData !== null) {
  4878.                     // Return the cached data if available
  4879.                     return $cachedData;
  4880.                 }
  4882.                 // If cache is empty, get the data from the API
  4883.                 $client = new Client(['verify' => false]);
  4884.                 $url1 = sprintf(
  4885.                     '%s/%s--%s:PT%sH/t_2m:C,wind_speed_10m:kmh,wind_dir_mean_100m_2h:d,prob_precip_2h:p,precip_2h:mm/%s,%s/json?model=' . $model . '&use_decluttered=true',
  4886.                     $this->apiBaseUrl,
  4887.                     $startDate,
  4888.                     $endDate,
  4889.                     $hour,
  4890.                     $latitude,
  4891.                     $longitude
  4892.                 );
  4893.             }
  4895.             $response = $client->request('GET', $url1, [
  4896.                 'auth' => [$this->username, $this->password],
  4897.             ]);
  4899.             $statusCode = $response->getStatusCode();
  4900.             $data1 = json_decode($response->getBody(), true);
  4902.             $this->redisCache->set($cacheKey, $data1);
  4904.             return $data1;
  4905.         } catch (GuzzleHttp\Exception\RequestException $e) {
  4906.             return throw new \Exception($e->getMessage());
  4907.         } catch (\Exception $e) {
  4908.             return throw new \Exception($e->getMessage());
  4909.         }
  4910.     }
  4913.     /**
  4914.      * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  4915.      *
  4916.      * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4917.      * @param int $days The number of days for which forecast is required
  4918.      * @return array|null The weather forecast data in JSON format, or null if there was an error
  4919.      */
  4920.     public function getTempratureByParamsHourly(
  4921.         array $coordinates,
  4922.             // Set the data to Re
  4923.         string $startDate,
  4924.         string $endDate,
  4925.         string $parametersStr,
  4926.         int $hour = 2,
  4927.         string $model,
  4928.         $timezone
  4929.     ) {
  4930.         try {
  4932.             // Convert start and end dates to the specified timezone
  4933.             $startDateObj = new \DateTime($startDate, $timezone);
  4934.             $endDateObj = new \DateTime($endDate, $timezone);
  4936.             // Format dates to ISO 8601 format for the API request
  4937.             $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  4938.             $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  4940.             if (count($coordinates) > 1) {
  4941.                 // Validate the input parameters
  4942.                 foreach ($coordinates as $coordinate) {
  4943.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4944.                         throw new \InvalidArgumentException('Invalid coordinates');
  4945.                     }
  4946.                 }
  4948.                 // Create a Redis key for the cache
  4949.                 $cacheKey = sprintf('hourly_custom_noti_%s_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  4950.                     return implode('_', $coordinate);
  4951.                 }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr, $model);
  4953.                 // Try to get the data from Redis cache
  4954.                 $cachedData = $this->redisCache->get($cacheKey);
  4955.                 if ($cachedData !== null) {
  4956.                     return $cachedData;
  4957.                 }
  4959.                 // Build the API URL
  4960.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4961.                 $url = sprintf(
  4962.                     '%s/%s--%s:PT%sH/%s/%s+%s/json?source=%s&use_decluttered=true',
  4963.                     $this->apiBaseUrl,
  4964.                     $startDate,
  4965.                     $endDate,
  4966.                     $hour,
  4967.                     $parametersStr,
  4968.                     $coordinateString,
  4969.                     $coordinateString,
  4970.                     $model
  4971.                 );
  4972.             } else {
  4973.                 // Handle single coordinate case
  4974.                 if ($coordinates) {
  4975.                     $latitude = $coordinates[0][0];
  4976.                     $longitude = $coordinates[0][1];
  4977.                 }
  4979.                 if (empty($latitude) || empty($longitude)) {
  4980.                     throw new \InvalidArgumentException('Invalid coordinates');
  4981.                 }
  4983.                 // Create a Redis key for the cache
  4984.                 $cacheKey = sprintf('hourly_custom_noti_%s_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  4985.                     return implode('_', $coordinate);
  4986.                 }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr, $model);
  4988.                 // Try to get the data from Redis cache
  4989.                 $cachedData = $this->redisCache->get($cacheKey);
  4990.                 if ($cachedData !== null) {
  4991.                     return $cachedData;
  4992.                 }
  4994.                 // Build the API URL for a single coordinate
  4995.                 $url = sprintf(
  4996.                     '%s/%s--%s:PT%sH/%s/%s,%s/json?source=%s&use_decluttered=true',
  4997.                     $this->apiBaseUrl,
  4998.                     $startDate,
  4999.                     $endDate,
  5000.                     $hour,
  5001.                     $parametersStr,
  5002.                     $latitude,
  5003.                     $longitude,
  5004.                     $model
  5005.                 );
  5006.             }
  5008.             // Make the API request
  5009.             $client = new Client(['verify' => false]);
  5010.             $response = $client->request('GET', $url, [
  5011.                 'auth' => [$this->username, $this->password],
  5012.             ]);
  5014.             $data = json_decode($response->getBody(), true);
  5016.             // Cache the data in Redis
  5017.             $this->redisCache->set($cacheKey, $data);
  5019.             return $data;
  5020.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5021.             throw new \Exception($e->getMessage());
  5022.         } catch (\Exception $e) {
  5023.             throw new \Exception($e->getMessage());
  5024.         }
  5025.     }
  5027.     /**
  5028.      * Tidal Amplitude
  5029.      *  
  5030.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5031.      * @param string $unit The type of data request unit (e.g., 'cm')
  5032.      * @param string $format return type of json
  5033.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5034.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5035.      * @param array $coordinates The latitude and longitude of location
  5036.      * @param string $model type of data Api return  (e.g., 'mm-tides')
  5037.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5038.      */
  5040.     public function getTidalAmplitudes(int $hour, $startDate, $endDate, array $coordinates, $unit, $model, $format)
  5041.     {
  5043.         try {
  5045.             if (count($coordinates) > 1) {
  5047.                 // Validate the input parameters
  5048.                 foreach ($coordinates as $coordinate) {
  5049.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5050.                         throw new \InvalidArgumentException('Invalid coordinates');
  5051.                     }
  5052.                 }
  5054.                 if (empty($startDate) || empty($endDate)) {
  5055.                     throw new \InvalidArgumentException('Invalid dates');
  5056.                 }
  5058.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5059.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5061.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $unit, $model, $format);
  5063.                 // Try to get the data from Redis cache
  5064.                 $cachedData = $this->redisCache->get($cacheKey);
  5066.                 if ($cachedData !== null) {
  5067.                     // Return the cached data if available
  5068.                     return $cachedData;
  5069.                 }
  5071.                 // If cache is empty, get the data from the API
  5072.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5073.                 $client = new Client(['verify' => false]);
  5075.                 $url = sprintf(
  5076.                     '%s/%s--%s:PT%sH/tidal_amplitude:%s/%s/%s?model=%s&use_decluttered=true',
  5077.                     $this->apiBaseUrl,
  5078.                     $startDate,
  5079.                     $endDate,
  5080.                     $hour,
  5081.                     $unit,
  5082.                     $coordinateString,
  5083.                     $format,
  5084.                     $model
  5085.                 );
  5087.                 $response = $client->request('GET', $url, [
  5088.                     'auth' => [$this->username, $this->password],
  5089.                 ]);
  5091.                 $statusCode = $response->getStatusCode();
  5092.                 $data = json_decode($response->getBody(), true);
  5094.                 if ($statusCode != 200) {
  5095.                     return $this->createErrorResponse($statusCode);
  5096.                 }
  5098.                 // Set the data to Redis cache
  5099.                 $this->redisCache->set($cacheKey, $data);
  5100.                 return $data;
  5101.             } else {
  5103.                 if ($coordinates) {
  5104.                     $latitude = $coordinates[0][0];
  5105.                     $longitude = $coordinates[0][1];
  5106.                 }
  5108.                 // Validate the input parameters
  5109.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5110.                     throw new \InvalidArgumentException('Invalid latitude');
  5111.                 }
  5113.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5114.                     throw new \InvalidArgumentException('Invalid longitude');
  5115.                 }
  5117.                 if (empty($startDate)) {
  5118.                     throw new \InvalidArgumentException('Invalid startDate');
  5119.                 }
  5120.                 if (empty($endDate)) {
  5121.                     throw new \InvalidArgumentException('Invalid endDate');
  5122.                 }
  5124.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5125.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5127.                 // Create a Redis key for the cache            
  5128.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $latitude, $longitude,  $model, $format);
  5130.                 // Try to get the data from Redis cache
  5131.                 $cachedData = $this->redisCache->get($cacheKey);
  5133.                 if ($cachedData !== null) {
  5134.                     // Return the cached data if available
  5135.                     return $cachedData;
  5136.                 }
  5138.                 // If cache is empty, get the data from the API
  5139.                 $client = new Client(['verify' => false]);
  5141.                 $url = sprintf(
  5142.                     '%s/%s--%s:PT%sH/tidal_amplitude:%s/%s,%s/%s?model=%s&use_decluttered=true',
  5143.                     $this->apiBaseUrl,
  5144.                     $startDate,
  5145.                     $endDate,
  5146.                     $hour,
  5147.                     $unit,
  5148.                     $latitude,
  5149.                     $longitude,
  5150.                     $format,
  5151.                     $model
  5152.                 );
  5154.                 $response = $client->request('GET', $url, [
  5155.                     'auth' => [$this->username, $this->password],
  5156.                 ]);
  5158.                 $statusCode = $response->getStatusCode();
  5159.                 $data = json_decode($response->getBody(), true);
  5161.                 if ($statusCode != 200) {
  5162.                     return $this->createErrorResponse($statusCode);
  5163.                 }
  5165.                 // Set the data to Redis cache
  5166.                 $this->redisCache->set($cacheKey, $data);
  5167.                 return $data;
  5168.             }
  5169.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5170.             return throw new \Exception($e->getMessage());
  5171.         } catch (\Exception $e) {
  5172.             return throw new \Exception($e->getMessage());
  5173.         }
  5174.     }
  5177.     /**
  5178.      * High and Low Tide Times
  5179.      *  
  5180.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5181.      * @param string $format return type of json
  5182.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5183.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5184.      * @param array $coordinates The latitude and longitude of location
  5185.      * @param string $model type of data Api return  (e.g., 'mm-tides')
  5186.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5187.      */
  5189.     public function getHighLowTideTimes(int $hour,  $startDate, $endDate, array $coordinates, $model, $format)
  5190.     {
  5192.         try {
  5194.             if (count($coordinates) > 1) {
  5196.                 // Validate the input parameters
  5197.                 foreach ($coordinates as $coordinate) {
  5198.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5199.                         throw new \InvalidArgumentException('Invalid coordinates');
  5200.                     }
  5201.                 }
  5203.                 if (empty($startDate) || empty($endDate)) {
  5204.                     throw new \InvalidArgumentException('Invalid dates');
  5205.                 }
  5207.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5208.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5210.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $model, $format);
  5212.                 // Try to get the data from Redis cache
  5213.                 $cachedData = $this->redisCache->get($cacheKey);
  5215.                 if ($cachedData !== null) {
  5216.                     // Return the cached data if available
  5217.                     return $cachedData;
  5218.                 }
  5220.                 // If cache is empty, get the data from the API
  5221.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5222.                 $client = new Client(['verify' => false]);
  5224.                 $url = sprintf(
  5225.                     '%s/%s--%s:PT%sH/first_high_tide:sql,second_high_tide:sql,first_low_tide:sql,second_low_tide:sql/%s/%s?model=%s&use_decluttered=true',
  5226.                     $this->apiBaseUrl,
  5227.                     $startDate,
  5228.                     $endDate,
  5229.                     $hour,
  5230.                     $coordinateString,
  5231.                     $format,
  5232.                     $model
  5233.                 );
  5235.                 $response = $client->request('GET', $url, [
  5236.                     'auth' => [$this->username, $this->password],
  5237.                 ]);
  5239.                 $statusCode = $response->getStatusCode();
  5240.                 $data = json_decode($response->getBody(), true);
  5242.                 if ($statusCode != 200) {
  5243.                     return $this->createErrorResponse($statusCode);
  5244.                 }
  5246.                 // Set the data to Redis cache
  5247.                 $this->redisCache->set($cacheKey, $data);
  5248.                 return $data;
  5249.             } else {
  5251.                 if ($coordinates) {
  5252.                     $latitude = $coordinates[0][0];
  5253.                     $longitude = $coordinates[0][1];
  5254.                 }
  5256.                 // Validate the input parameters
  5257.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5258.                     throw new \InvalidArgumentException('Invalid latitude');
  5259.                 }
  5261.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5262.                     throw new \InvalidArgumentException('Invalid longitude');
  5263.                 }
  5265.                 if (empty($startDate)) {
  5266.                     throw new \InvalidArgumentException('Invalid startDate');
  5267.                 }
  5268.                 if (empty($endDate)) {
  5269.                     throw new \InvalidArgumentException('Invalid endDate');
  5270.                 }
  5272.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5273.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5275.                 // Create a Redis key for the cache            
  5276.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude,  $model, $format);
  5278.                 // Try to get the data from Redis cache
  5279.                 $cachedData = $this->redisCache->get($cacheKey);
  5281.                 if ($cachedData !== null) {
  5282.                     // Return the cached data if available
  5283.                     return $cachedData;
  5284.                 }
  5286.                 // If cache is empty, get the data from the API
  5287.                 $client = new Client(['verify' => false]);
  5289.                 $url = sprintf(
  5290.                     '%s/%s--%s:PT%sH/first_high_tide:sql,second_high_tide:sql,first_low_tide:sql,second_low_tide:sql/%s,%s/%s?model=%s&use_decluttered=true',
  5291.                     $this->apiBaseUrl,
  5292.                     $startDate,
  5293.                     $endDate,
  5294.                     $hour,
  5295.                     $latitude,
  5296.                     $longitude,
  5297.                     $format,
  5298.                     $model
  5299.                 );
  5301.                 $response = $client->request('GET', $url, [
  5302.                     'auth' => [$this->username, $this->password],
  5303.                 ]);
  5305.                 $statusCode = $response->getStatusCode();
  5306.                 $data = json_decode($response->getBody(), true);
  5308.                 if ($statusCode != 200) {
  5309.                     return $this->createErrorResponse($statusCode);
  5310.                 }
  5312.                 // Set the data to Redis cache
  5313.                 $this->redisCache->set($cacheKey, $data);
  5314.                 return $data;
  5315.             }
  5316.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5317.             return throw new \Exception($e->getMessage());
  5318.         } catch (\Exception $e) {
  5319.             return throw new \Exception($e->getMessage());
  5320.         }
  5321.     }
  5323.     /**
  5324.      * Significant Wave Height
  5325.      *  
  5326.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5327.      * @param string $format return type of json
  5328.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5329.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5330.      * @param array $coordinates The latitude and longitude of location
  5331.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5332.      */
  5333.     public function getSignificantWaveHeight(int $hour,  $startDate,  $endDate, array $coordinates, $format)
  5334.     {
  5336.         try {
  5338.             if (count($coordinates) > 1) {
  5340.                 // Validate the input parameters
  5341.                 foreach ($coordinates as $coordinate) {
  5342.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5343.                         throw new \InvalidArgumentException('Invalid coordinates');
  5344.                     }
  5345.                 }
  5347.                 if (empty($startDate) || empty($endDate)) {
  5348.                     throw new \InvalidArgumentException('Invalid dates');
  5349.                 }
  5351.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5352.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5354.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate, $format);
  5356.                 // Try to get the data from Redis cache
  5357.                 $cachedData = $this->redisCache->get($cacheKey);
  5359.                 if ($cachedData !== null) {
  5360.                     // Return the cached data if available
  5361.                     return $cachedData;
  5362.                 }
  5364.                 // If cache is empty, get the data from the API
  5365.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5366.                 $client = new Client(['verify' => false]);
  5368.                 $url = sprintf(
  5369.                     '%s/%s--%s:PT%sH/significant_height_wind_waves:m/%s/%s?use_decluttered=true',
  5370.                     $this->apiBaseUrl,
  5371.                     $startDate,
  5372.                     $endDate,
  5373.                     $hour,
  5374.                     $coordinateString,
  5375.                     $format
  5376.                 );
  5378.                 $response = $client->request('GET', $url, [
  5379.                     'auth' => [$this->username, $this->password],
  5380.                 ]);
  5382.                 $statusCode = $response->getStatusCode();
  5383.                 $data = json_decode($response->getBody(), true);
  5385.                 if ($statusCode != 200) {
  5386.                     return $this->createErrorResponse($statusCode);
  5387.                 }
  5389.                 // Set the data to Redis cache
  5390.                 $this->redisCache->set($cacheKey, $data);
  5391.                 return $data;
  5392.             } else {
  5394.                 if ($coordinates) {
  5395.                     $latitude = $coordinates[0][0];
  5396.                     $longitude = $coordinates[0][1];
  5397.                 }
  5399.                 // Validate the input parameters
  5400.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5401.                     throw new \InvalidArgumentException('Invalid latitude');
  5402.                 }
  5404.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5405.                     throw new \InvalidArgumentException('Invalid longitude');
  5406.                 }
  5408.                 if (empty($startDate)) {
  5409.                     throw new \InvalidArgumentException('Invalid startDate');
  5410.                 }
  5412.                 if (empty($endDate)) {
  5413.                     throw new \InvalidArgumentException('Invalid endDate');
  5414.                 }
  5416.                 $startDate = date('Y-m-d\TH\Z', (strtotime($startDate)));
  5417.                 $endDate = date('Y-m-d\TH\Z', (strtotime($endDate)));
  5419.                 // Create a Redis key for the cache            
  5420.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $format);
  5422.                 // Try to get the data from Redis cache
  5423.                 $cachedData = $this->redisCache->get($cacheKey);
  5425.                 if ($cachedData !== null) {
  5426.                     // Return the cached data if available
  5427.                     return $cachedData;
  5428.                 }
  5430.                 // If cache is empty, get the data from the API
  5431.                 $client = new Client(['verify' => false]);
  5433.                 $url = sprintf(
  5434.                     '%s/%s--%s:PT%sH/significant_height_wind_waves:m/%s,%s/%s?use_decluttered=true',
  5435.                     $this->apiBaseUrl,
  5436.                     $startDate,
  5437.                     $endDate,
  5438.                     $hour,
  5439.                     $latitude,
  5440.                     $longitude,
  5441.                     $format
  5442.                 );
  5444.                 $response = $client->request('GET', $url, [
  5445.                     'auth' => [$this->username, $this->password],
  5446.                 ]);
  5448.                 $statusCode = $response->getStatusCode();
  5449.                 $data = json_decode($response->getBody(), true);
  5451.                 if ($statusCode != 200) {
  5452.                     return $this->createErrorResponse($statusCode);
  5453.                 }
  5455.                 // Set the data to Redis cache
  5456.                 $this->redisCache->set($cacheKey, $data);
  5457.                 return $data;
  5458.             }
  5459.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5460.             return throw new \Exception($e->getMessage());
  5461.         } catch (\Exception $e) {
  5462.             return throw new \Exception($e->getMessage());
  5463.         }
  5464.     }
  5466.     /**
  5467.      * Surge Amplitude
  5468.      *  
  5469.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5470.      * @param string $format return type of json
  5471.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5472.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5473.      * @param string $unit The type of data unit (e.g., 'cm')
  5474.      * @param array $coordinates The latitude and longitude of location
  5475.      * @param string $model type of data Api return  (e.g., 'mix')
  5476.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5477.      */
  5479.     public function getSurgeAmplitude(int $hour,  $startDate,  $endDate, array $coordinates, $unit, $model, $format)
  5480.     {
  5482.         try {
  5484.             if (count($coordinates) > 1) {
  5486.                 // Validate the input parameters
  5487.                 foreach ($coordinates as $coordinate) {
  5488.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5489.                         throw new \InvalidArgumentException('Invalid coordinates');
  5490.                     }
  5491.                 }
  5493.                 if (empty($startDate) || empty($endDate)) {
  5494.                     throw new \InvalidArgumentException('Invalid dates');
  5495.                 }
  5497.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5498.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5500.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate, $unit,  $model, $format);
  5502.                 // Try to get the data from Redis cache
  5503.                 $cachedData = $this->redisCache->get($cacheKey);
  5505.                 if ($cachedData !== null) {
  5506.                     // Return the cached data if available
  5507.                     return $cachedData;
  5508.                 }
  5510.                 // If cache is empty, get the data from the API
  5511.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5512.                 $client = new Client(['verify' => false]);
  5514.                 $url = sprintf(
  5515.                     '%s/%s--%s:PT%sH/surge_amplitude:%s/%s/%s?model=%s&use_decluttered=true',
  5516.                     $this->apiBaseUrl,
  5517.                     $startDate,
  5518.                     $endDate,
  5519.                     $hour,
  5520.                     $unit,
  5521.                     $coordinateString,
  5522.                     $format,
  5523.                     $model
  5524.                 );
  5526.                 $response = $client->request('GET', $url, [
  5527.                     'auth' => [$this->username, $this->password],
  5528.                 ]);
  5530.                 $statusCode = $response->getStatusCode();
  5531.                 $data = json_decode($response->getBody(), true);
  5533.                 if ($statusCode != 200) {
  5534.                     return $this->createErrorResponse($statusCode);
  5535.                 }
  5537.                 // Set the data to Redis cache
  5538.                 $this->redisCache->set($cacheKey, $data);
  5539.                 return $data;
  5540.             } else {
  5542.                 if ($coordinates) {
  5543.                     $latitude = $coordinates[0][0];
  5544.                     $longitude = $coordinates[0][1];
  5545.                 }
  5547.                 // Validate the input parameters
  5548.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5549.                     throw new \InvalidArgumentException('Invalid latitude');
  5550.                 }
  5552.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5553.                     throw new \InvalidArgumentException('Invalid longitude');
  5554.                 }
  5556.                 if (empty($startDate)) {
  5557.                     throw new \InvalidArgumentException('Invalid startDate');
  5558.                 }
  5559.                 if (empty($endDate)) {
  5560.                     throw new \InvalidArgumentException('Invalid endDate');
  5561.                 }
  5563.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5564.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5566.                 // Create a Redis key for the cache            
  5567.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $unit,  $model, $format);
  5569.                 // Try to get the data from Redis cache
  5570.                 $cachedData = $this->redisCache->get($cacheKey);
  5572.                 if ($cachedData !== null) {
  5573.                     // Return the cached data if available
  5574.                     return $cachedData;
  5575.                 }
  5577.                 // If cache is empty, get the data from the API
  5578.                 $client = new Client(['verify' => false]);
  5580.                 $url = sprintf(
  5581.                     '%s/%s--%s:PT%sH/surge_amplitude:%s/%s,%s/%s?model=%s&use_decluttered=true',
  5582.                     $this->apiBaseUrl,
  5583.                     $startDate,
  5584.                     $endDate,
  5585.                     $hour,
  5586.                     $unit,
  5587.                     $latitude,
  5588.                     $longitude,
  5589.                     $format,
  5590.                     $model
  5591.                 );
  5593.                 $response = $client->request('GET', $url, [
  5594.                     'auth' => [$this->username, $this->password],
  5595.                 ]);
  5597.                 $statusCode = $response->getStatusCode();
  5598.                 $data = json_decode($response->getBody(), true);
  5600.                 if ($statusCode != 200) {
  5601.                     return $this->createErrorResponse($statusCode);
  5602.                 }
  5604.                 // Set the data to Redis cache
  5605.                 $this->redisCache->set($cacheKey, $data);
  5606.                 return $data;
  5607.             }
  5608.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5609.             return throw new \Exception($e->getMessage());
  5610.         } catch (\Exception $e) {
  5611.             return throw new \Exception($e->getMessage());
  5612.         }
  5613.     }
  5616.     /**
  5617.      * Heat index
  5618.      *  
  5619.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5620.      * @param string $format return type of json
  5621.      * @param string $unit request unit type (e.g, 'C')
  5622.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5623.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5624.      * @param array $coordinates The latitude and longitude of location
  5625.      * @param string $model type of data Api return  (e.g., 'mix')
  5626.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5627.      */
  5629.     public function getHeatIndex(int $hour,  $startDate,  $endDate, array $coordinates,  $unit,  $format, $model)
  5630.     {
  5633.         try {
  5635.             if (count($coordinates) > 1) {
  5637.                 // Validate the input parameters
  5638.                 foreach ($coordinates as $coordinate) {
  5639.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5640.                         throw new \InvalidArgumentException('Invalid coordinates');
  5641.                     }
  5642.                 }
  5644.                 if (empty($startDate) || empty($endDate)) {
  5645.                     throw new \InvalidArgumentException('Invalid dates');
  5646.                 }
  5648.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5649.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5651.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate,  $model, $unit, $format);
  5653.                 // Try to get the data from Redis cache
  5654.                 $cachedData = $this->redisCache->get($cacheKey);
  5656.                 if ($cachedData !== null) {
  5657.                     // Return the cached data if available
  5658.                     return $cachedData;
  5659.                 }
  5661.                 // If cache is empty, get the data from the API
  5662.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5663.                 $client = new Client(['verify' => false]);
  5664.                 $url = sprintf(
  5665.                     '%s/%s--%s:PT%sH/heat_index:%s,t_2m:%s/%s/%s?model=%s&use_decluttered=true',
  5666.                     $this->apiBaseUrl,
  5667.                     $startDate,
  5668.                     $endDate,
  5669.                     $hour,
  5670.                     $unit,
  5671.                     $unit,
  5672.                     $coordinateString,
  5673.                     $format,
  5674.                     $model
  5675.                 );
  5677.                 $response = $client->request('GET', $url, [
  5678.                     'auth' => [$this->username, $this->password],
  5679.                 ]);
  5681.                 $statusCode = $response->getStatusCode();
  5682.                 $data = json_decode($response->getBody(), true);
  5684.                 if ($statusCode != 200) {
  5685.                     return $this->createErrorResponse($statusCode);
  5686.                 }
  5688.                 // Set the data to Redis cache
  5689.                 $this->redisCache->set($cacheKey, $data);
  5690.                 return $data;
  5691.             } else {
  5693.                 if ($coordinates) {
  5694.                     $latitude = $coordinates[0][0];
  5695.                     $longitude = $coordinates[0][1];
  5696.                 }
  5698.                 // Validate the input parameters
  5699.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5700.                     throw new \InvalidArgumentException('Invalid latitude');
  5701.                 }
  5703.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5704.                     throw new \InvalidArgumentException('Invalid longitude');
  5705.                 }
  5707.                 if (empty($startDate)) {
  5708.                     throw new \InvalidArgumentException('Invalid startDate');
  5709.                 }
  5710.                 if (empty($endDate)) {
  5711.                     throw new \InvalidArgumentException('Invalid endDate');
  5712.                 }
  5714.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5715.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5717.                 // Create a Redis key for the cache            
  5718.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude,  $unit,  $model, $format);
  5720.                 // Try to get the data from Redis cache
  5721.                 $cachedData = $this->redisCache->get($cacheKey);
  5723.                 if ($cachedData !== null) {
  5724.                     // Return the cached data if available
  5725.                     return $cachedData;
  5726.                 }
  5728.                 // If cache is empty, get the data from the API
  5729.                 $client = new Client(['verify' => false]);
  5730.                 $url = sprintf(
  5731.                     '%s/%s--%s:PT%sH/heat_index:%s,t_2m:%s/%s,%s/%s?model=%s&use_decluttered=true',
  5732.                     $this->apiBaseUrl,
  5733.                     $startDate,
  5734.                     $endDate,
  5735.                     $hour,
  5736.                     $unit,
  5737.                     $unit,
  5738.                     $latitude,
  5739.                     $longitude,
  5740.                     $format,
  5741.                     $model
  5742.                 );
  5744.                 $response = $client->request('GET', $url, [
  5745.                     'auth' => [$this->username, $this->password],
  5746.                 ]);
  5748.                 $statusCode = $response->getStatusCode();
  5749.                 $data = json_decode($response->getBody(), true);
  5751.                 if ($statusCode != 200) {
  5752.                     return $this->createErrorResponse($statusCode);
  5753.                 }
  5755.                 // Set the data to Redis cache
  5756.                 $this->redisCache->set($cacheKey, $data);
  5757.                 return $data;
  5758.             }
  5759.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5760.             return throw new \Exception($e->getMessage());
  5761.         } catch (\Exception $e) {
  5762.             return throw new \Exception($e->getMessage());
  5763.         }
  5764.     }
  5768.     /**
  5769.      * Atmospheric Density
  5770.      *  
  5771.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5772.      * @param string $format return type of json
  5773.      * @param string $level The type of level request (e.g., '2m')
  5774.      * @param string $unit The type of unit request (e.g., 'kgm3')
  5775.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5776.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5777.      * @param array $coordinates The latitude and longitude of location
  5778.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5779.      */
  5781.     public function getAirdensity(int $hour,  $startDate,  $endDate, array $coordinates, $level, $unit, $format)
  5782.     {
  5784.         try {
  5786.             if (count($coordinates) > 1) {
  5788.                 // Validate the input parameters
  5789.                 foreach ($coordinates as $coordinate) {
  5790.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5791.                         throw new \InvalidArgumentException('Invalid coordinates');
  5792.                     }
  5793.                 }
  5795.                 if (empty($startDate) || empty($endDate)) {
  5796.                     throw new \InvalidArgumentException('Invalid dates');
  5797.                 }
  5799.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5800.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5802.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates,  $level, $unit, $format);
  5804.                 // Try to get the data from Redis cache
  5805.                 $cachedData = $this->redisCache->get($cacheKey);
  5807.                 if ($cachedData !== null) {
  5808.                     // Return the cached data if available
  5809.                     return $cachedData;
  5810.                 }
  5812.                 // If cache is empty, get the data from the API
  5813.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5814.                 $client = new Client(['verify' => false]);
  5815.                 $url = sprintf(
  5816.                     '%s/%s--%s:PT%sH/air_density_%s:%s/%s/%s?use_decluttered=true',
  5817.                     $this->apiBaseUrl,
  5818.                     $startDate,
  5819.                     $endDate,
  5820.                     $hour,
  5821.                     $level,
  5822.                     $unit,
  5823.                     $coordinateString,
  5824.                     $format
  5825.                 );
  5827.                 $response = $client->request('GET', $url, [
  5828.                     'auth' => [$this->username, $this->password],
  5829.                 ]);
  5831.                 $statusCode = $response->getStatusCode();
  5832.                 $data = json_decode($response->getBody(), true);
  5834.                 if ($statusCode != 200) {
  5835.                     return $this->createErrorResponse($statusCode);
  5836.                 }
  5838.                 // Set the data to Redis cache
  5839.                 $this->redisCache->set($cacheKey, $data);
  5840.                 return $data;
  5841.             } else {
  5843.                 if ($coordinates) {
  5844.                     $latitude = $coordinates[0][0];
  5845.                     $longitude = $coordinates[0][1];
  5846.                 }
  5848.                 // Validate the input parameters
  5849.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5850.                     throw new \InvalidArgumentException('Invalid latitude');
  5851.                 }
  5853.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5854.                     throw new \InvalidArgumentException('Invalid longitude');
  5855.                 }
  5857.                 if (empty($startDate)) {
  5858.                     throw new \InvalidArgumentException('Invalid startDate');
  5859.                 }
  5860.                 if (empty($endDate)) {
  5861.                     throw new \InvalidArgumentException('Invalid endDate');
  5862.                 }
  5864.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5865.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5867.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude,  $level, $unit, $format);
  5869.                 // Try to get the data from Redis cache
  5870.                 $cachedData = $this->redisCache->get($cacheKey);
  5872.                 if ($cachedData !== null) {
  5873.                     // Return the cached data if available
  5874.                     return $cachedData;
  5875.                 }
  5877.                 // If cache is empty, get the data from the API
  5878.                 $client = new Client(['verify' => false]);
  5879.                 $url = sprintf(
  5880.                     '%s/%s--%s:PT%sH/air_density_%s:%s/%s,%s/%s?use_decluttered=true',
  5881.                     $this->apiBaseUrl,
  5882.                     $startDate,
  5883.                     $endDate,
  5884.                     $hour,
  5885.                     $level,
  5886.                     $unit,
  5887.                     $latitude,
  5888.                     $longitude,
  5889.                     $format
  5890.                 );
  5892.                 $response = $client->request('GET', $url, [
  5893.                     'auth' => [$this->username, $this->password],
  5894.                 ]);
  5896.                 $statusCode = $response->getStatusCode();
  5897.                 $data = json_decode($response->getBody(), true);
  5899.                 if ($statusCode != 200) {
  5900.                     return $this->createErrorResponse($statusCode);
  5901.                 }
  5903.                 // Set the data to Redis cache
  5904.                 $this->redisCache->set($cacheKey, $data);
  5905.                 return $data;
  5906.             }
  5907.         } catch (GuzzleHttp\Exception\RequestException $e) {
  5908.             return throw new \Exception($e->getMessage());
  5909.         } catch (\Exception $e) {
  5910.             return throw new \Exception($e->getMessage());
  5911.         }
  5912.     }
  5914.     /**
  5915.      * Soil Moisture Index
  5916.      *  
  5917.      * @param string $hourly The hour for which forecast is required in 24-hour format
  5918.      * @param string $format return type of json
  5919.      * @param string $level The type of level request (e.g., '2m')
  5920.      * @param string $unit The type of unit request (e.g., 'kgm3')
  5921.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  5922.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  5923.      * @param array $coordinates The latitude and longitude of location
  5924.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  5925.      */
  5927.     public function getSoilMoistureIndex(int $hour,  $startDate,  $endDate, array $coordinates, $level, $unit, $format)
  5928.     {
  5930.         try {
  5932.             if (count($coordinates) > 1) {
  5934.                 // Validate the input parameters
  5935.                 foreach ($coordinates as $coordinate) {
  5936.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5937.                         throw new \InvalidArgumentException('Invalid coordinates');
  5938.                     }
  5939.                 }
  5941.                 if (empty($startDate) || empty($endDate)) {
  5942.                     throw new \InvalidArgumentException('Invalid dates');
  5943.                 }
  5945.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5946.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5948.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates,  $level, $unit, $format);
  5950.                 // Try to get the data from Redis cache
  5951.                 $cachedData = $this->redisCache->get($cacheKey);
  5953.                 if ($cachedData !== null) {
  5954.                     // Return the cached data if available
  5955.                     return $cachedData;
  5956.                 }
  5958.                 // If cache is empty, get the data from the API
  5959.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5960.                 $client = new Client(['verify' => false]);
  5961.                 $url = sprintf(
  5962.                     '%s/%s--%s:PT%sH/soil_moisture_index_%s:%s/%s/%s?use_decluttered=true',
  5963.                     $this->apiBaseUrl,
  5964.                     $startDate,
  5965.                     $endDate,
  5966.                     $hour,
  5967.                     $level,
  5968.                     $unit,
  5969.                     $coordinateString,
  5970.                     $format
  5971.                 );
  5973.                 $response = $client->request('GET', $url, [
  5974.                     'auth' => [$this->username, $this->password],
  5975.                 ]);
  5977.                 $statusCode = $response->getStatusCode();
  5978.                 $data = json_decode($response->getBody(), true);
  5980.                 if ($statusCode != 200) {
  5981.                     return $this->createErrorResponse($statusCode);
  5982.                 }
  5984.                 // Set the data to Redis cache
  5985.                 $this->redisCache->set($cacheKey, $data);
  5986.                 return $data;
  5987.             } else {
  5989.                 if ($coordinates) {
  5990.                     $latitude = $coordinates[0][0];
  5991.                     $longitude = $coordinates[0][1];
  5992.                 }
  5994.                 // Validate the input parameters
  5995.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5996.                     throw new \InvalidArgumentException('Invalid latitude');
  5997.                 }
  5999.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6000.                     throw new \InvalidArgumentException('Invalid longitude');
  6001.                 }
  6003.                 if (empty($startDate)) {
  6004.                     throw new \InvalidArgumentException('Invalid startDate');
  6005.                 }
  6006.                 if (empty($endDate)) {
  6007.                     throw new \InvalidArgumentException('Invalid endDate');
  6008.                 }
  6010.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6011.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6013.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude,  $level, $unit, $format);
  6015.                 // Try to get the data from Redis cache
  6016.                 $cachedData = $this->redisCache->get($cacheKey);
  6018.                 if ($cachedData !== null) {
  6019.                     // Return the cached data if available
  6020.                     return $cachedData;
  6021.                 }
  6023.                 // If cache is empty, get the data from the API
  6024.                 $client = new Client(['verify' => false]);
  6025.                 $url = sprintf(
  6026.                     '%s/%s--%s:PT%sH/soil_moisture_index_%s:%s/%s,%s/%s?use_decluttered=true',
  6027.                     $this->apiBaseUrl,
  6028.                     $startDate,
  6029.                     $endDate,
  6030.                     $hour,
  6031.                     $level,
  6032.                     $unit,
  6033.                     $latitude,
  6034.                     $longitude,
  6035.                     $format
  6036.                 );
  6038.                 $response = $client->request('GET', $url, [
  6039.                     'auth' => [$this->username, $this->password],
  6040.                 ]);
  6042.                 $statusCode = $response->getStatusCode();
  6043.                 $data = json_decode($response->getBody(), true);
  6045.                 if ($statusCode != 200) {
  6046.                     return $this->createErrorResponse($statusCode);
  6047.                 }
  6049.                 // Set the data to Redis cache
  6050.                 $this->redisCache->set($cacheKey, $data);
  6051.                 return $data;
  6052.             }
  6053.         } catch (GuzzleHttp\Exception\RequestException $e) {
  6054.             return throw new \Exception($e->getMessage());
  6055.         } catch (\Exception $e) {
  6056.             return throw new \Exception($e->getMessage());
  6057.         }
  6058.     }
  6060.     /**
  6061.      * Frost & Thaw Depth
  6062.      *  
  6063.      * @param string $hourly The hour for which forecast is required in 24-hour format
  6064.      * @param string $format return type of json
  6065.      * @param string $startDate The type of data date (e.g., '2023-09-01')
  6066.      * @param string $endDate The type of data date (e.g., '2023-09-01')
  6067.      * @param string $unit The type of data request (e.g., 'cm')
  6068.      * @param array $coordinates The latitude and longitude of location
  6069.      * @throws \InvalidArgumentException If any parameter has an invalid data type
  6070.      */
  6071.     public function getFrostThawAndDepth(int $hour,  $startDate,  $endDate, $unit, array $coordinates, $format)
  6072.     {
  6074.         try {
  6076.             if (count($coordinates) > 1) {
  6078.                 // Validate the input parameters
  6079.                 foreach ($coordinates as $coordinate) {
  6080.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6081.                         throw new \InvalidArgumentException('Invalid coordinates');
  6082.                     }
  6083.                 }
  6085.                 if (empty($startDate) || empty($endDate)) {
  6086.                     throw new \InvalidArgumentException('Invalid dates');
  6087.                 }
  6089.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6090.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6092.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $coordinates, $format);
  6094.                 // Try to get the data from Redis cache
  6095.                 $cachedData = $this->redisCache->get($cacheKey);
  6097.                 if ($cachedData !== null) {
  6098.                     // Return the cached data if available
  6099.                     return $cachedData;
  6100.                 }
  6102.                 // If cache is empty, get the data from the API
  6103.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6104.                 $client = new Client(['verify' => false]);
  6105.                 $url = sprintf(
  6106.                     '%s/%s--%s:PT%sH/frost_depth:%s,thaw_depth:%s/%s/%s?use_decluttered=true',
  6107.                     $this->apiBaseUrl,
  6108.                     $startDate,
  6109.                     $endDate,
  6110.                     $hour,
  6111.                     $unit,
  6112.                     $unit,
  6113.                     $coordinateString,
  6114.                     $format
  6115.                 );
  6117.                 $response = $client->request('GET', $url, [
  6118.                     'auth' => [$this->username, $this->password],
  6119.                 ]);
  6121.                 $statusCode = $response->getStatusCode();
  6122.                 $data = json_decode($response->getBody(), true);
  6124.                 if ($statusCode != 200) {
  6125.                     return $this->createErrorResponse($statusCode);
  6126.                 }
  6128.                 // Set the data to Redis cache
  6129.                 $this->redisCache->set($cacheKey, $data);
  6130.                 return $data;
  6131.             } else {
  6133.                 if ($coordinates) {
  6134.                     $latitude = $coordinates[0][0];
  6135.                     $longitude = $coordinates[0][1];
  6136.                 }
  6138.                 // Validate the input parameters
  6139.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6140.                     throw new \InvalidArgumentException('Invalid latitude');
  6141.                 }
  6143.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6144.                     throw new \InvalidArgumentException('Invalid longitude');
  6145.                 }
  6147.                 if (empty($startDate)) {
  6148.                     throw new \InvalidArgumentException('Invalid startDate');
  6149.                 }
  6150.                 if (empty($endDate)) {
  6151.                     throw new \InvalidArgumentException('Invalid endDate');
  6152.                 }
  6154.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6155.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6157.                 $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $latitude, $longitude, $format);
  6159.                 // Try to get the data from Redis cache
  6160.                 $cachedData = $this->redisCache->get($cacheKey);
  6162.                 if ($cachedData !== null) {
  6163.                     // Return the cached data if available
  6164.                     return $cachedData;
  6165.                 }
  6167.                 // If cache is empty, get the data from the API
  6168.                 $client = new Client(['verify' => false]);
  6169.                 $url = sprintf(
  6170.                     '%s/%s--%s:PT%sH/frost_depth:%s,thaw_depth:%s/%s,%s/%s?use_decluttered=true',
  6171.                     $this->apiBaseUrl,
  6172.                     $startDate,
  6173.                     $endDate,
  6174.                     $hour,
  6175.                     $unit,
  6176.                     $unit,
  6177.                     $latitude,
  6178.                     $longitude,
  6179.                     $format
  6180.                 );
  6182.                 $response = $client->request('GET', $url, [
  6183.                     'auth' => [$this->username, $this->password],
  6184.                 ]);
  6186.                 $statusCode = $response->getStatusCode();
  6187.                 $data = json_decode($response->getBody(), true);
  6189.                 if ($statusCode != 200) {
  6190.                     return $this->createErrorResponse($statusCode);
  6191.                 }
  6193.                 // Set the data to Redis cache
  6194.                 $this->redisCache->set($cacheKey, $data);
  6195.                 return $data;
  6196.             }
  6197.         } catch (GuzzleHttp\Exception\RequestException $e) {
  6198.             return throw new \Exception($e->getMessage());
  6199.         } catch (\Exception $e) {
  6200.             return throw new \Exception($e->getMessage());
  6201.         }
  6202.     }
  6204.     public function getReportForecastData(array $coordinates, string $startDate, string $endDate, int $hours, string $model = "ksancm-wrf-48", array $parameters = [], $translator, array $cities, $params)
  6205.     {
  6206.         try {
  6207.                 if (count($coordinates) > 1) {
  6208.                     // Validate the input parameters
  6209.                     foreach ($coordinates as $coordinate) {
  6210.                         if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6211.                             // throw new \InvalidArgumentException('Invalid coordinates');
  6212.                             return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  6213.                         }
  6214.                     }
  6215.                 }else{
  6216.                     if ($coordinates) {
  6217.                         $latitude = $coordinates[0][0];
  6218.                         $longitude = $coordinates[0][1];
  6219.                     }
  6220.                     // Validate the input parameters
  6221.                     if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6222.                         // throw new \InvalidArgumentException('Invalid latitude');
  6223.                         return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  6224.                     }
  6225.                     if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6226.                         // throw new \InvalidArgumentException('Invalid longitude');
  6227.                         return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  6228.                     }
  6229.                 }
  6230.     
  6231.                 if (empty($startDate) || empty($endDate)) {
  6232.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6233.                     // throw new \InvalidArgumentException('Invalid dates');
  6234.                 }
  6235.                 if ($hours < 1 and $hours > 24) {
  6236.                     throw new \InvalidArgumentException('Invalid hour');
  6237.                 }
  6238.                 $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6239.                 $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6240.                 if (empty($parameters)) {
  6241.                     $parameters = [
  6242.                         't_2m:C',
  6243.                         't_max_2m_%sh:C',
  6244.                         't_min_2m_%sh:C',
  6245.                         't_apparent_min_%sh:C',
  6246.                         't_apparent_max_%sh:C',
  6247.                         'wind_speed_mean_10m_%sh:kmh',
  6248.                         'wind_dir_mean_10m_%sh:d',
  6249.                         'prob_precip_%sh:p',
  6250.                         'precip_%sh:mm',
  6251.                         'relative_humidity_mean_2m_%sh:p',
  6252.                         'effective_cloud_cover_mean_%sh:octas',
  6253.                         'dew_point_mean_2m_%sh:C',
  6254.                         'wind_gusts_10m_%sh:kmh',
  6255.                         'visibility:km',
  6256.                     ];
  6257.                 }
  6258.                 // Create a Redis key for the cache
  6259.                 $cacheKey = sprintf('daily_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6260.                     return implode('_', $coordinate);
  6261.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters));
  6262.                 // Try to get the data from Redis cache
  6263.                 $cachedData = $this->redisCache->get($cacheKey);
  6264.                 if ($cachedData !== null) {
  6265.                     // Return the cached data if available
  6266.                     return $cachedData;
  6267.                 }
  6268.     
  6269.                 $timeResolutions = [
  6270.                     '_24h' => '+1 day',
  6271.                     '_12h' => '+12 hours',
  6272.                     '_6h' => '+6 hours',
  6273.                     '_3h' => '+3 hours',
  6274.                     '_1h' => '+1 hour'
  6275.                 ];
  6276.     
  6277.                 $adjustedParameters = [];
  6278.                 $nonAdjustedParameters = [];
  6279.     
  6280.                 foreach ($parameters as $parameter) {
  6281.                     $matched = false;
  6282.                     foreach ($timeResolutions as $key => $adjustment) {
  6283.                         if (strpos($parameter, $key) !== false) {
  6284.                             $matched = true;
  6285.                             $adjustedParameters[$adjustment][] = $parameter;
  6286.                             break;
  6287.                         }
  6288.                     }
  6289.                     if (!$matched) {
  6290.                         $nonAdjustedParameters[] = $parameter;
  6291.                     }
  6292.                 }
  6293.                 // Construct the URL
  6294.                 // $url = "{$this->apiBaseUrl}/{$startDate}--{$endDate}:{$duration}/t_2m:C,wind_speed_10m:kmh,wind_dir_10m:d,sfs_pressure:hPa,precip_10min:mm,relative_humidity_2m:p,visibility:km,dew_point_2m:c,wind_gusts_10m_1h:kmh,ceiling_height_agl:m,geopotential_height:m,t_min_2m_24h:C,t_max_2m_24h:C,precip_24h:mm,total_cloud_cover:octas/metar_{$metar}/json?source=mix-obs&on_invalid=fill_with_invalid";
  6295.                 $dataFinal = [
  6296.                     'data' => []
  6297.                 ];
  6298.     
  6299.                 foreach ($adjustedParameters as $adjustment => $adjParams) {
  6300.                     $adjustedStartDate = (new \DateTime($startDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  6301.                     $adjustedEndDate = (new \DateTime($endDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  6302.                     $data = $this->fetchReportForecastData($coordinates,$adjustedStartDate,$adjustedEndDate,$hours, $model,$adjParams,$translator,$cities, $params);
  6303.                     // Revert dates to original range
  6304.                     if (isset($data['data']) && is_array($data['data'])) {
  6305.     
  6306.                         foreach ($data['data'] as &$datum) {
  6307.                             if (isset($datum['coordinates']) && is_array($datum['coordinates'])) {
  6308.                                 foreach ($datum['coordinates'] as &$coordinate) {
  6309.                                     if (isset($coordinate['dates']) && is_array($coordinate['dates'])) {
  6310.                                         foreach ($coordinate['dates'] as &$date) {
  6311.                                             if (isset($date['date'])) {
  6312.                                                 // Convert the date back by subtracting the adjustment
  6313.                                                 $adjustmentValue = str_replace(['+', ' '], '', $adjustment); // Remove '+' and extra spaces
  6314.                                                 $date['date'] = (new \DateTime($date['date']))
  6315.                                                     ->modify('-' . $adjustmentValue)
  6316.                                                     ->format('Y-m-d\TH:i:s\Z');
  6317.                                             }
  6318.                                         }
  6319.                                     }
  6320.                                 }
  6321.                             }
  6322.                         }
  6323.                     } else {
  6324.                         $data['data'] = []; // Ensure 'data' exists
  6325.                     }
  6326.     
  6327.                     // Merge into $dataFinal
  6328.                     if (empty($dataFinal['version'])) {
  6329.                         $dataFinal['version'] = $data['version'] ?? null;
  6330.                         $dataFinal['user'] = $data['user'] ?? null;
  6331.                         $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  6332.                         $dataFinal['status'] = $data['status'] ?? null;
  6333.                     }
  6334.     
  6335.                     if (isset($data['data']) && is_array($data['data'])) {
  6336.                         $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  6337.                     }
  6338.                 }
  6339.                 // Process non-adjusted parameters
  6340.                 if (!empty($nonAdjustedParameters)) {
  6341.                     $data= $this->fetchReportForecastData($coordinates,$startDate,$endDate,$hours, $model ,$nonAdjustedParameters,$translator,$cities, $params);
  6342.                     if (isset($data['data']) && is_array($data['data'])) {
  6343.                         $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  6344.                     }
  6345.                 }
  6346.                 // Reorder data based on parameters
  6347.                     $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  6348.                     ? $this->orderResults($dataFinal['data'], $parameters)
  6349.                     : [];
  6350.     
  6351.                 $result = [];
  6352.                 foreach ($dataFinal['data'] as $param) {
  6353.                     foreach ($param['coordinates'] as $paramCoordinates) {
  6354.                         // exit;
  6355.                         $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6356.                         $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6357.                         $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6358.                         if (!isset($result[$cityKey])) {
  6359.                             $result[$cityKey] = [];
  6360.                             if (isset($cities[$cityKey]['en'])) {
  6361.                                 $result[$cityKey] = [
  6362.                                     'cityEn' => $cities[$cityKey]['en'],
  6363.                                     'cityAr' => $cities[$cityKey]['ar'],
  6364.                                     'lat' => $paramCoordinates['lat'],
  6365.                                     'lon' => $paramCoordinates['lon'],
  6366.                                     'parameters' => [],
  6367.                                 ];
  6368.                             } else {
  6369.                                 $result[$cityKey] = [
  6370.                                     'city' => $cities[$cityKey],
  6371.                                     'lat' => $paramCoordinates['lat'],
  6372.                                     'lon' => $paramCoordinates['lon'],
  6373.                                     'parameters' => [],
  6374.                                 ];
  6375.                             }
  6376.                         }
  6377.                         $parameterData = [
  6378.                             'parameter' => $param['parameter'],
  6379.                             'dates' => [],
  6380.                         ]; 
  6381.                         foreach ($paramCoordinates['dates'] as $item) {
  6382.                             $parameterData['dates'][] = [
  6383.                                 'date' => $item['date'], // You can modify this as needed
  6384.                                 'value' => $item['value'], // You can modify this as needed
  6385.                             ];
  6386.                         }
  6387.     
  6388.                         // p_r($parameterData);
  6389.                         $result[$cityKey]['parameters'][] = $parameterData;
  6390.                     }
  6391.                 }
  6392.     
  6393.                 $result = array_values($result);
  6394.                 if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6395.                     $latestReport = new Report\Listing();
  6396.                     $latestReport->setCondition('reportType__id = ?', [$params['report_type_id']]);
  6397.                     $latestReport->setOrderKey("o_creationDate");
  6398.                     $latestReport->setOrder("desc");
  6399.                     $latestReport = $latestReport->current();
  6400.                     if ($latestReport) {
  6401.                         $jsonData = json_decode($latestReport->getJsonData(), true);
  6402.                         foreach ($result as &$value) {
  6403.                             // Compare latitude and longitude
  6404.                             foreach ($jsonData as $jsonEntry) {
  6405.                                 if ($value['lat'] == $jsonEntry['lat'] && $value['lon'] == $jsonEntry['lon']) {
  6406.                                     // Latitude and longitude match, proceed with parameter comparison
  6407.                                     foreach ($value['parameters'] as &$paramValue) {
  6408.                                         foreach ($jsonEntry['parameters'] as $jsonParam) {
  6409.                                             if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6410.                                                 // Parameter matches, check dates now
  6411.                                                 foreach ($paramValue['dates'] as &$dateValue) {
  6412.                                                     foreach ($jsonParam['dates'] as $jsonDate) {
  6413.                                                         if ($dateValue['date'] == $jsonDate['date']) {
  6414.                                                             // Exact match found, override the value
  6415.                                                             $dateValue['value'] = $jsonDate['value'];
  6416.                                                             // Continue checking all dates, no break here
  6417.                                                         }
  6418.                                                     }
  6419.                                                 }
  6420.                                                 unset($dateValue); // Ensure reference is not carried over
  6421.                                             }
  6422.                                         }
  6423.                                     }
  6424.                                     unset($paramValue); // Ensure reference is not carried over
  6425.                                 }
  6426.                             }
  6427.                         }
  6428.                         unset($value); // Ensure reference is not carried over
  6429.                     }
  6430.                 }
  6431.     
  6432.             // Set the data to Redis cache
  6433.             $this->redisCache->set($cacheKey, $dataFinal);
  6434.             return $result;
  6435.         } catch (GuzzleHttp\Exception\RequestException $e) {
  6436.             return throw new \Exception($e->getMessage());
  6437.         } catch (\Exception $e) {
  6438.             return throw new \Exception($e->getMessage());
  6439.         }
  6440.     }
  6441.     
  6442.     public function fetchReportForecastData($coordinates,$startDate,$endDate,$hours, $model,$parameters,$translator,$cities, $params){
  6443.         $dataFinal = [];
  6444.          $client = new Client(['verify' => false]);
  6445.          if (count($coordinates) > 1) {
  6446.          $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6447.          }else{
  6448.             if ($coordinates) {
  6449.                 $latitude = $coordinates[0][0];
  6450.                 $longitude = $coordinates[0][1];
  6451.             }
  6452.          }
  6453.                 while (!empty($parameters)) {
  6454.     
  6455.                     $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6456.                     $batchQueryString = implode(',', $batchParameters);
  6457.                     $batchQueryString = str_replace('%s', $hours, $batchQueryString);
  6458.     
  6459.                     if (count($coordinates) > 1) {
  6460.                         $url = sprintf(
  6461.                         '%s/%s--%s:PT%sH/%s/%s/json?model=%s&use_decluttered=true',
  6462.                         $this->apiBaseUrl,
  6463.                         $startDate,
  6464.                         $endDate,
  6465.                         $hours,
  6466.                         $batchQueryString,
  6467.                         $coordinateString,
  6468.                         $model
  6469.                     );
  6470.                     }else{
  6471.                         $url = sprintf(
  6472.                             '%s/%s--%s:PT%sH/%s/%s,%s/json?model=%s&use_decluttered=true',
  6473.                             $this->apiBaseUrl,
  6474.                             $startDate,
  6475.                             $endDate,
  6476.                             $hours,
  6477.                             $batchQueryString,
  6478.                             $latitude,
  6479.                             $longitude,
  6480.                             $model
  6481.                         );
  6482.                     }
  6483.                     $response = $client->request('GET', $url, [
  6484.                         'auth' => [$this->username, $this->password],
  6485.                     ]);
  6486.                     $statusCode = $response->getStatusCode();
  6487.                     $data = json_decode($response->getBody(), true);
  6488.                     // Merge data from the current API call into the final data
  6489.                     $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  6490.                 }
  6491.                 foreach ($coordinates as $coOrd) {
  6492.                     $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT' . $hours . 'H', $hours . 'h', true);
  6493.                     if (isset($weatherSymbols['data'][0]['parameter'])) {
  6494.                         $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6495.                     }
  6496.                 }
  6497.                 // p_r($dataFinal);
  6498.                 // exit;
  6499.     
  6500.                 // Convert the associative array to indexed array
  6501.     
  6502.                 return $dataFinal;
  6503.     
  6504.     }
  6505.     public function getAdminReportForecastData(array $coordinates, string $startDate, string $endDate, string $model = "ksancm-wrf-48", array $parameters12h = [], array $parameters24h = [], $translator, array $cities, $params)
  6506.     {
  6507.         try {
  6509.             if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6510.                 $latestReport = new Report\Listing();
  6511.                 $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6512.                 $latestReport->filterByReportType($reportType);
  6513.                 $latestReport->setOrderKey("createdOn");
  6514.                 $latestReport->setLimit(1);
  6515.                 $latestReport->setOrder("desc");
  6516.                 $latestReport = $latestReport->current();
  6517.             }
  6519.             if (count($coordinates) > 1) {
  6521.                 // Validate the input parameters
  6522.                 foreach ($coordinates as $coordinate) {
  6523.                     if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6524.                         // throw new \InvalidArgumentException('Invalid coordinates');
  6525.                         return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  6526.                     }
  6527.                 }
  6528.                 if (empty($startDate) || empty($endDate)) {
  6529.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6530.                     // throw new \InvalidArgumentException('Invalid dates');
  6531.                 }
  6533.                 // Create a Redis key for the cache
  6534.                 $cacheKey = sprintf('daily_forecast_%s_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6535.                     return implode('_', $coordinate);
  6536.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters12h), implode('_', $parameters24h));
  6537.                 // Try to get the data from Redis cache
  6538.                 $cachedData = $this->redisCache->get($cacheKey);
  6539.                 if ($cachedData !== null) {
  6540.                     // Return the cached data if available
  6541.                     // return $cachedData;
  6542.                 }
  6543.                 // If cache is empty, get the data from the API
  6544.                 $client = new Client(['verify' => false]);
  6545.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6546.                 $dataFinal = [];
  6547.                 // Function to perform the API requests for given parameters and hours
  6548.                 $performApiRequests = function ($parameters, $hours, $startDate, $endDate) use ($client, $coordinateString, $model) {
  6549.                     $data = [];
  6550.                     while (!empty($parameters)) {
  6551.                         $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6552.                         $batchQueryString = implode(',', $batchParameters);
  6553.                         $url = sprintf(
  6554.                             '%s/%s--%s:PT%sH/%s/%s/json?model=%s&use_decluttered=true',
  6555.                             $this->apiBaseUrl,
  6556.                             $startDate,
  6557.                             $endDate,
  6558.                             $hours,
  6559.                             $batchQueryString,
  6560.                             $coordinateString,
  6561.                             $model
  6562.                         );
  6563.                         $response = $client->request('GET', $url, [
  6564.                             'auth' => [$this->username, $this->password],
  6565.                         ]);
  6566.                         $statusCode = $response->getStatusCode();
  6567.                         $dataBatch = json_decode($response->getBody(), true);
  6568.                         // Merge data from the current API call into the data array
  6569.                         $data['data'] = array_merge($data['data'] ?? [], $dataBatch['data']);
  6570.                     }
  6571.                     return $data;
  6572.                 };
  6575.                 // Process 24h parameters
  6576.                 if (!empty($parameters24h)) {
  6578.                     $startDateUpdated = new DateTime($startDate);
  6579.                     $endDateUpdated = new DateTime($endDate);
  6581.                     $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6582.                     $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6585.                     $data24h = $performApiRequests($parameters24h, 24, $startDateUpdated, $endDateUpdated);
  6587.                     if (!empty($data24h)) {
  6588.                         foreach ($data24h['data'] as &$datum) {
  6590.                             if (isset($datum['coordinates'])) {
  6591.                                 foreach ($datum['coordinates'] as &$coordinate) {
  6592.                                     foreach ($coordinate['dates'] as &$date) {
  6593.                                         $dateObj = new DateTime($date['date']);
  6594.                                         $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6595.                                     }
  6596.                                 }
  6597.                             }
  6598.                         }
  6600.                         // Correctly append 24h data to $datainal
  6601.                         if (!empty($data24h['data'])) {
  6602.                             // Existing code to adjust dates in $data24h['data']
  6603.                             if (empty($dataFinal['data'])) {
  6604.                                 $dataFinal['data'] = $data24h['data'];
  6605.                             } else {
  6606.                                 $dataFinal['data'] = array_merge($dataFinal['data'], $data24h['data']);
  6607.                             }
  6608.                         }
  6609.                     }
  6610.                 }
  6612.                 // Process 12h parameters
  6613.                 if (!empty($parameters12h)) {
  6615.                     $startDateUpdated = new DateTime($startDate);
  6616.                     $endDateUpdated = new DateTime($endDate);
  6618.                     $startDateUpdated = $startDateUpdated->modify('+12 hours')->format('Y-m-d\TH:i:s\Z');
  6619.                     $endDateUpdated = $endDateUpdated->modify('+12 hours')->format('Y-m-d\TH:i:s\Z');
  6621.                     $data12h = $performApiRequests($parameters12h, 12, $startDateUpdated, $endDateUpdated);
  6623.                     if (!empty($data12h)) {
  6625.                         foreach ($data12h['data'] as &$datum) {
  6627.                             if (isset($datum['coordinates'])) {
  6628.                                 foreach ($datum['coordinates'] as &$coordinate) {
  6629.                                     foreach ($coordinate['dates'] as &$date) {
  6630.                                         $dateObj = new DateTime($date['date']);
  6631.                                         $date['date'] = $dateObj->modify('-12 hours')->format('Y-m-d\TH:i:s\Z');
  6632.                                     }
  6633.                                 }
  6634.                             }
  6635.                         }
  6636.                         // Correctly append 12h data to $dataFinal
  6637.                         if (!empty($data12h['data'])) {
  6638.                             // Existing code to adjust dates in $data12h['data']
  6639.                             if (empty($dataFinal['data'])) {
  6640.                                 $dataFinal['data'] = $data12h['data'];
  6641.                             } else {
  6642.                                 $dataFinal['data'] = array_merge($dataFinal['data'], $data12h['data']);
  6643.                             }
  6644.                         }
  6645.                     }
  6646.                 }
  6648.                 foreach ($coordinates as $coOrd) {
  6649.                     $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT12H', '12h');
  6650.                     if (isset($weatherSymbols['data'][0]['parameter'])) {
  6651.                         $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6652.                     }
  6653.                 }
  6655.                 $result = [];
  6657.                 foreach ($dataFinal['data'] as $param) {
  6659.                     foreach ($param['coordinates'] as $paramCoordinates) {
  6661.                         $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6662.                         $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6663.                         $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6665.                         if (!isset($result[$cityKey])) {
  6666.                             $result[$cityKey] = [];
  6667.                             if (isset($cities[$cityKey]['en'])) {
  6668.                                 if (isset($paramCoordinates['lat']) && isset($paramCoordinates['lon'])) {
  6669.                                     $result[$cityKey] = [
  6670.                                         'cityEn' => $cities[$cityKey]['en'],
  6671.                                         'cityAr' => $cities[$cityKey]['ar'],
  6672.                                         'lat' => $paramCoordinates['lat'],
  6673.                                         'lon' => $paramCoordinates['lon'],
  6674.                                         'parameters' => [],
  6675.                                     ];
  6676.                                 }
  6677.                             } else {
  6678.                                 if (isset($paramCoordinates['lat']) && isset($paramCoordinates['lon'])) {
  6679.                                     $result[$cityKey] = [
  6680.                                         'city' => $cities[$cityKey],
  6681.                                         'lat' => $paramCoordinates['lat'],
  6682.                                         'lon' => $paramCoordinates['lon'],
  6683.                                         'parameters' => [],
  6684.                                     ];
  6685.                                 }
  6686.                             }
  6687.                         }
  6689.                         $parameterData = [
  6690.                             'parameter' => $param['parameter'],
  6691.                             'dates' => [],
  6692.                         ];
  6694.                         foreach ($paramCoordinates['dates'] as $date) {
  6695.                             $parameterData['dates'][] = [
  6696.                                 'date' => $date['date'], // You can modify this as needed
  6697.                                 'value' => $date['value'], // You can modify this as needed
  6698.                             ];
  6699.                         }
  6701.                         $result[$cityKey]['parameters'][] = $parameterData;
  6702.                     }
  6703.                 }
  6705.                 // Convert the associative array to indexed array
  6706.                 $result = array_values($result);
  6707.                 if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6709.                     // $latestReport = new Report\Listing();
  6710.                     // $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6711.                     // $latestReport->filterByReportType($reportType);
  6712.                     // $latestReport->setOrderKey("createdOn");
  6713.                     // $latestReport->setOrder("desc");
  6714.                     // $latestReport = $latestReport->current();
  6716.                     if ($latestReport) {
  6717.                         $jsonData = json_decode($latestReport->getJsonData(), true);
  6718.                         foreach ($result as &$value) {
  6719.                             // Compare latitude and longitude
  6720.                             foreach ($jsonData as $jsonEntry) {
  6721.                                 if (isset($value['lat']) && isset($jsonEntry['lat']) && ($value['lat'] == $jsonEntry['lat']) && isset($value['lon']) && isset($jsonEntry['lon']) && ($value['lon'] == $jsonEntry['lon'])) {
  6722.                                     // Latitude and longitude match, proceed with parameter comparison
  6723.                                     foreach ($value['parameters'] as &$paramValue) {
  6724.                                         foreach ($jsonEntry['parameters'] as $jsonParam) {
  6725.                                             if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6726.                                                 // Parameter matches, check dates now
  6727.                                                 foreach ($paramValue['dates'] as &$dateValue) {
  6728.                                                     foreach ($jsonParam['dates'] as $jsonDate) {
  6729.                                                         if ($dateValue['date'] == $jsonDate['date']) {
  6730.                                                             // Exact match found, override the value
  6731.                                                             $dateValue['value'] = $jsonDate['value'];
  6732.                                                             // Continue checking all dates, no break here
  6733.                                                         }
  6734.                                                     }
  6735.                                                 }
  6736.                                                 unset($dateValue); // Ensure reference is not carried over
  6737.                                             }
  6738.                                         }
  6739.                                     }
  6740.                                     unset($paramValue); // Ensure reference is not carried over
  6741.                                 }
  6742.                             }
  6743.                         }
  6744.                         unset($value); // Ensure reference is not carried over
  6745.                     }
  6746.                 }
  6747.             } else {
  6749.                 if ($coordinates) {
  6750.                     $latitude = $coordinates[0][0];
  6751.                     $longitude = $coordinates[0][1];
  6752.                 }
  6753.                 // Validate the input parameters
  6754.                 if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6755.                     // throw new \InvalidArgumentException('Invalid latitude');
  6756.                     return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  6757.                 }
  6758.                 if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6759.                     // throw new \InvalidArgumentException('Invalid longitude');
  6760.                     return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  6761.                 }
  6762.                 if (empty($startDate) || empty($endDate)) {
  6763.                     return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6764.                 }
  6767.                 // Create a Redis key for the cache
  6768.                 $cacheKey = sprintf('daily_forecast_%s_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6769.                     return implode('_', $coordinate);
  6770.                 }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters12h), implode('_', $parameters24h));
  6771.                 // Try to get the data from Redis cache
  6772.                 $cachedData = $this->redisCache->get($cacheKey);
  6773.                 if ($cachedData !== null) {
  6774.                     // Return the cached data if available
  6775.                     return $cachedData;
  6776.                 }
  6779.                 // If cache is empty, get the data from the API
  6780.                 $client = new Client(['verify' => false]);
  6781.                 $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6782.                 $dataFinal = [];
  6783.                 // Function to perform the API requests for given parameters and hours
  6784.                 $performApiRequests = function ($parameters, $hours, $startDate, $endDate) use ($client, $latitude, $longitude, $model) {
  6785.                     $data = [];
  6786.                     while (!empty($parameters)) {
  6787.                         $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6788.                         $batchQueryString = implode(',', $batchParameters);
  6789.                         $url = sprintf(
  6790.                             '%s/%s--%s:PT%sH/%s/%s,%s/json?model=%s&use_decluttered=true',
  6791.                             $this->apiBaseUrl,
  6792.                             $startDate,
  6793.                             $endDate,
  6794.                             $hours,
  6795.                             $batchQueryString,
  6796.                             $latitude,
  6797.                             $longitude,
  6798.                             $model
  6799.                         );
  6800.                         $response = $client->request('GET', $url, [
  6801.                             'auth' => [$this->username, $this->password],
  6802.                             'timeout' => 600
  6803.                         ]);
  6804.                         $statusCode = $response->getStatusCode();
  6805.                         $dataBatch = json_decode($response->getBody(), true);
  6806.                         // Merge data from the current API call into the data array
  6807.                         $data['data'] = array_merge($data['data'] ?? [], $dataBatch['data']);
  6808.                     }
  6809.                     return $data;
  6810.                 };
  6814.                 // Process 24h parameters
  6815.                 if (!empty($parameters24h)) {
  6817.                     $startDateUpdated = new DateTime($startDate);
  6818.                     $endDateUpdated = new DateTime($endDate);
  6820.                     $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6821.                     $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6824.                     $data24h = $performApiRequests($parameters24h, 24, $startDateUpdated, $endDateUpdated);
  6826.                     if (!empty($data24h)) {
  6827.                         foreach ($data24h['data'] as &$datum) {
  6829.                             if (isset($datum['coordinates'])) {
  6830.                                 foreach ($datum['coordinates'] as &$coordinate) {
  6831.                                     foreach ($coordinate['dates'] as &$date) {
  6832.                                         $dateObj = new DateTime($date['date']);
  6833.                                         $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6834.                                     }
  6835.                                 }
  6836.                             }
  6837.                         }
  6839.                         // Correctly append 24h data to $datainal
  6840.                         if (!empty($data24h['data'])) {
  6841.                             // Existing code to adjust dates in $data24h['data']
  6842.                             if (empty($dataFinal['data'])) {
  6843.                                 $dataFinal['data'] = $data24h['data'];
  6844.                             } else {
  6845.                                 $dataFinal['data'] = array_merge($dataFinal['data'], $data24h['data']);
  6846.                             }
  6847.                         }
  6848.                     }
  6849.                 }
  6851.                 // Process 12h parameters
  6852.                 if (!empty($parameters12h)) {
  6854.                     $startDateUpdated = new DateTime($startDate);
  6855.                     $endDateUpdated = new DateTime($endDate);
  6857.                     $startDateUpdated = $startDateUpdated->modify('+12 hours')->format('Y-m-d\TH:i:s\Z');
  6858.                     $endDateUpdated = $endDateUpdated->modify('+12 hours')->format('Y-m-d\TH:i:s\Z');
  6860.                     $data12h = $performApiRequests($parameters12h, 12, $startDateUpdated, $endDateUpdated);
  6862.                     if (!empty($data12h)) {
  6864.                         foreach ($data12h['data'] as &$datum) {
  6866.                             if (isset($datum['coordinates'])) {
  6867.                                 foreach ($datum['coordinates'] as &$coordinate) {
  6868.                                     foreach ($coordinate['dates'] as &$date) {
  6869.                                         $dateObj = new DateTime($date['date']);
  6870.                                         $date['date'] = $dateObj->modify('-12 hours')->format('Y-m-d\TH:i:s\Z');
  6871.                                     }
  6872.                                 }
  6873.                             }
  6874.                         }
  6875.                         // Correctly append 12h data to $dataFinal
  6876.                         if (!empty($data12h['data'])) {
  6877.                             // Existing code to adjust dates in $data12h['data']
  6878.                             if (empty($dataFinal['data'])) {
  6879.                                 $dataFinal['data'] = $data12h['data'];
  6880.                             } else {
  6881.                                 $dataFinal['data'] = array_merge($dataFinal['data'], $data12h['data']);
  6882.                             }
  6883.                         }
  6884.                     }
  6885.                 }
  6887.                 foreach ($coordinates as $coOrd) {
  6888.                     $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT12H', '12h');
  6889.                     if (isset($weatherSymbols['data'][0]['parameter'])) {
  6890.                         $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6891.                     }
  6892.                 }
  6896.                 $result = [];
  6898.                 foreach ($dataFinal['data'] as $param) {
  6899.                     foreach ($param['coordinates'] as $paramCoordinates) {
  6900.                         $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6901.                         $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6902.                         $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6904.                         if (!isset($result[$cityKey])) {
  6905.                             $result[$cityKey] = [];
  6906.                             if (isset($cities[$cityKey]['en'])) {
  6908.                                 $result[$cityKey] = [
  6909.                                     'cityEn' => $cities[$cityKey]['en'],
  6910.                                     'cityAr' => $cities[$cityKey]['ar'],
  6911.                                     'lat' => $paramCoordinates['lat'],
  6912.                                     'lon' => $paramCoordinates['lon'],
  6913.                                     'parameters' => [],
  6914.                                 ];
  6915.                             } else {
  6916.                                 $result[$cityKey] = [
  6917.                                     'city' => $cities[$cityKey],
  6918.                                     'lat' => $paramCoordinates['lat'],
  6919.                                     'lon' => $paramCoordinates['lon'],
  6920.                                     'parameters' => [],
  6921.                                 ];
  6922.                             }
  6923.                         }
  6925.                         $parameterData = [
  6926.                             'parameter' => $param['parameter'],
  6927.                             'dates' => [],
  6928.                         ];
  6930.                         foreach ($paramCoordinates['dates'] as $date) {
  6931.                             $parameterData['dates'][] = [
  6932.                                 'date' => $date['date'], // You can modify this as needed
  6933.                                 'value' => $date['value'], // You can modify this as needed
  6934.                             ];
  6935.                         }
  6937.                         $result[$cityKey]['parameters'][] = $parameterData;
  6938.                     }
  6939.                 }
  6941.                 // Convert the associative array to indexed array
  6942.                 $result = array_values($result);
  6943.                 if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6944.                     // $latestReport = new Report\Listing();
  6945.                     // $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6946.                     // $latestReport->filterByReportType($reportType);
  6947.                     // $latestReport->setOrderKey("createdOn");
  6948.                     // $latestReport->setOrder("desc");
  6949.                     // $latestReport = $latestReport->current();
  6950.                     if ($latestReport) {
  6951.                         $jsonData = json_decode($latestReport->getJsonData(), true);
  6952.                         foreach ($result as &$value) {
  6953.                             // Compare latitude and longitude
  6954.                             foreach ($jsonData as $jsonEntry) {
  6955.                                 if ($value['lat'] == $jsonEntry['lat'] && $value['lon'] == $jsonEntry['lon']) {
  6956.                                     // Latitude and longitude match, proceed with parameter comparison
  6957.                                     foreach ($value['parameters'] as &$paramValue) {
  6958.                                         foreach ($jsonEntry['parameters'] as $jsonParam) {
  6959.                                             if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6960.                                                 // Parameter matches, check dates now
  6961.                                                 foreach ($paramValue['dates'] as &$dateValue) {
  6962.                                                     foreach ($jsonParam['dates'] as $jsonDate) {
  6963.                                                         if ($dateValue['date'] == $jsonDate['date']) {
  6964.                                                             // Exact match found, override the value
  6965.                                                             $dateValue['value'] = $jsonDate['value'];
  6966.                                                             // Continue checking all dates, no break here
  6967.                                                         }
  6968.                                                     }
  6969.                                                 }
  6970.                                                 unset($dateValue); // Ensure reference is not carried over
  6971.                                             }
  6972.                                         }
  6973.                                     }
  6974.                                     unset($paramValue); // Ensure reference is not carried over
  6975.                                 }
  6976.                             }
  6977.                         }
  6978.                         unset($value); // Ensure reference is not carried over
  6979.                     }
  6980.                 }
  6981.             }
  6982.             // Set the data to Redis cache
  6983.             // $this->redisCache->set($cacheKey, $dataFinal);
  6984.             return $result;
  6985.         } catch (GuzzleHttp\Exception\RequestException $e) {
  6986.             // p_r($e->getMessage());
  6987.             return throw new \Exception($e->getMessage());
  6988.         } catch (\Exception $e) {
  6989.             return throw new \Exception($e->getMessage());
  6990.         }
  6991.     }
  6994.     public function getBarbs(string $windSpeed, string $dateTime, string $resolution, string $accessToken): array
  6995.     {
  6996.         try {
  6997.             $client = new Client(['verify' => false]);
  6998.             $url = sprintf(
  6999.                 "%s/mvt/barbs/%s/style.json?datetime=%s&resolution=%s&access_token=%s&use_decluttered=true",
  7000.                 $this->apiBaseUrl,
  7001.                 $windSpeed,
  7002.                 $dateTime,
  7003.                 $resolution,
  7004.                 $accessToken
  7005.             );
  7007.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7008.             $data = json_decode($response->getBody(), true);
  7009.             return $data;
  7010.         } catch (RequestException $e) {
  7011.             throw new \Exception($e->getMessage());
  7012.         } catch (\Exception $e) {
  7013.             throw new \Exception($e->getMessage());
  7014.         }
  7015.     }
  7019.     public function getMaskLayerData(string $query): array
  7020.     {
  7021.         try {
  7022.             $client = new Client(['verify' => false]);
  7023.             $url = sprintf(
  7024.                 "%s/%s",
  7025.                 $this->apiBaseUrl,
  7026.                 $query
  7027.             );
  7029.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7030.             $data = json_decode($response->getBody(), true);
  7031.             return $data;
  7032.         } catch (RequestException $e) {
  7033.             throw new \Exception($e->getMessage());
  7034.         } catch (\Exception $e) {
  7035.             throw new \Exception($e->getMessage());
  7036.         }
  7037.     }
  7039.     public function getIsolines(string $measure, string $dateTime, string $accessToken): array
  7040.     {
  7041.         try {
  7042.             $client = new Client(['verify' => false]);
  7043.             $url = sprintf(
  7044.                 "%s/mvt/isolines/%s/style.json?datetime=%s&access_token=%s&use_decluttered=true",
  7045.                 $this->apiBaseUrl,
  7046.                 $measure,
  7047.                 $dateTime,
  7048.                 $accessToken
  7049.             );
  7051.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7052.             $data = json_decode($response->getBody(), true);
  7053.             return $data;
  7054.         } catch (RequestException $e) {
  7055.             throw new \Exception($e->getMessage());
  7056.         } catch (\Exception $e) {
  7057.             throw new \Exception($e->getMessage());
  7058.         }
  7059.     }
  7061.     public function getAviationReports(string $meter, string $dateTime, string $accessToken): array
  7062.     {
  7063.         try {
  7064.             $client = new Client(['verify' => false]);
  7065.             $url = sprintf(
  7066.                 "%s/mvt/aviation_reports/%s/style.json?datetime=%s&access_token=%s&use_decluttered=true",
  7067.                 $this->apiBaseUrl,
  7068.                 $meter,
  7069.                 $dateTime,
  7070.                 $accessToken
  7071.             );
  7073.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7074.             $data = json_decode($response->getBody(), true);
  7075.             return $data;
  7076.         } catch (RequestException $e) {
  7077.             throw new \Exception($e->getMessage());
  7078.         } catch (\Exception $e) {
  7079.             throw new \Exception($e->getMessage());
  7080.         }
  7081.     }
  7083.     public function getOceanCurrentSpeed(string $dateTime, string $bBox): array
  7084.     {
  7085.         try {
  7086.             $client = new Client(['verify' => false]);
  7087.             $url = sprintf(
  7088.                 "%s/%s/ocean_current_u:ms,ocean_current_v:ms/%s/json?use_decluttered=true",
  7089.                 $this->apiBaseUrl,
  7090.                 $dateTime,
  7091.                 $bBox
  7092.             );
  7094.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7095.             $data = json_decode($response->getBody(), true);
  7096.             return $data;
  7097.         } catch (RequestException $e) {
  7098.             throw new \Exception($e->getMessage());
  7099.         } catch (\Exception $e) {
  7100.             throw new \Exception($e->getMessage());
  7101.         }
  7102.     }
  7104.     public function getWMSMAP(string $legendGraphics, string $format, string $layer, string $style = '')
  7105.     {
  7106.         try {
  7107.             $client = new Client(['verify' => false]);
  7109.             // Conditionally add the STYLE parameter to the URL if it's provided
  7110.             $stylePart = $style ? "&STYLE=" . urlencode($style) : '';
  7112.             $url = sprintf(
  7113.                 "%s/wms?VERSION=1.3.0&REQUEST=%s&FORMAT=%s&LAYER=%s%s&use_decluttered=true",
  7114.                 $this->apiBaseUrl,
  7115.                 $legendGraphics,
  7116.                 $format,
  7117.                 $layer,
  7118.                 $stylePart
  7119.             );
  7121.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7123.             // Get the raw body content
  7124.             $content = $response->getBody()->getContents();
  7126.             // Set headers and create a response object for the PNG image
  7127.             $httpResponse = new Response($content, Response::HTTP_OK, [
  7128.                 'Content-Type' => $format
  7129.             ]);
  7131.             return $httpResponse;
  7132.         } catch (RequestException $e) {
  7133.             throw new \Exception($e->getMessage());
  7134.         } catch (\Exception $e) {
  7135.             throw new \Exception($e->getMessage());
  7136.         }
  7137.     }
  7140.     public function getWeatherStationData(string $typeName, string $parameters, string $dateTime, string $bBox)
  7141.     {
  7142.         try {
  7143.             $dateTimeObj = new \DateTime($dateTime);
  7144.             $dateTimeObj->sub(new \DateInterval('PT10M'));
  7145.             $adjustedDateTime = $dateTimeObj->format('Y-m-d\TH:i:s.v\Z');
  7146.             
  7147.             $client = new Client(['verify' => false]);
  7148.             $url = sprintf(
  7149.                 "%s/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=%s&PARAMETERS=%s&TIME=%s&BBOX=%s&use_decluttered=true",
  7150.                 $this->apiBaseUrl,
  7151.                 $typeName,
  7152.                 $parameters,
  7153.                 $adjustedDateTime,
  7154.                 $bBox
  7155.             );
  7157.             $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7159.             // Get the raw body content
  7160.             $content = $response->getBody()->getContents();
  7162.             // Set headers and create a response object for the XML File
  7163.             $httpResponse = new Response($content, Response::HTTP_OK, [
  7164.                 'Content-Type' => 'application/xml'
  7165.             ]);
  7167.             return $httpResponse;
  7169.             // return $response->getBody();
  7170.         } catch (RequestException $e) {
  7171.             throw new \Exception($e->getMessage());
  7172.         } catch (\Exception $e) {
  7173.             throw new \Exception($e->getMessage());
  7174.         }
  7175.     }
  7177.     function getGridLayer($dateTime, $parameter, $coordinates, $resolution, $format, $source, $bbox, $calibrated, $translator)
  7178.     {
  7179.         try {
  7181.             if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $dateTime)) {
  7182.                 throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7183.             }
  7185.             if (!$parameter) {
  7186.                 throw new \InvalidArgumentException($translator->trans('invalid_unit'));
  7187.             }
  7189.             if (count($coordinates) < 1 || !is_array($coordinates[0]) || count($coordinates[0]) < 2) {
  7190.                 throw new \InvalidArgumentException($translator->trans('invalid_co_ordinates'));
  7191.             }
  7193.             if (!preg_match('/^\d+x\d+$/', $resolution)) {
  7194.                 throw new \InvalidArgumentException($translator->trans('invalid_resolution'));
  7195.             }
  7197.             if (!in_array($format, ['json', 'xml', 'csv'])) {
  7198.                 throw new \InvalidArgumentException($translator->trans('invalid_format'));
  7199.             }
  7201.             if (!is_string($source)) {
  7202.                 throw new \InvalidArgumentException($translator->trans('invalid_source'));
  7203.             }
  7205.             if (count($bbox) !== 4) {
  7206.                 throw new \InvalidArgumentException($translator->trans('invalid_bbox_elements'));
  7207.             }
  7209.             if (!in_array($calibrated, ['true', 'false'])) {
  7210.                 throw new \InvalidArgumentException($translator->trans('invalid_calibrated_value'));
  7211.             }
  7213.             $dateTime = urlencode($dateTime);
  7214.             $coordinateString = implode('_', array_map(fn($coords) => implode(',', $coords), $coordinates));
  7215.             $bboxString = implode(',', $bbox);
  7217.             $cacheKey = \App\Lib\Utility::generateKey($dateTime, $coordinateString, $bboxString, $parameter);
  7218.             $cachedData = $this->redisCache->get($cacheKey);
  7220.             if ($cachedData !== null) {
  7221.                 // Return the cached data if available
  7222.                 return $cachedData;
  7223.             }
  7225.             // Construct the URL
  7226.             $url = "{$this->apiBaseUrl}/{$dateTime}/{$parameter}/{$coordinateString}:{$resolution}/{$format}?source={$source}&bbox={$bboxString}&calibrated={$calibrated}&use_decluttered=true";
  7228.             $client = new Client(['verify' => false]);
  7230.             $response = $client->request('GET', $url, [
  7231.                 'auth' => [$this->username, $this->password],
  7232.             ]);
  7234.             $statusCode = $response->getStatusCode();
  7235.             $data = json_decode($response->getBody(), true);
  7237.             if ($statusCode != 200) {
  7238.                 return $this->createErrorResponse($statusCode);
  7239.             }
  7241.             // Set the data to Redis cache
  7242.             $this->redisCache->set($cacheKey, $data);
  7243.             return $data;
  7244.         } catch (RequestException $e) {
  7245.             throw new \Exception($e->getMessage());
  7246.         } catch (\Exception $e) {
  7247.             throw new \Exception($e->getMessage());
  7248.         }
  7249.     }
  7250.     public function getMetarData($startDate, $endDate, $metar, $duration, $translator, $parameter, $genExcel)
  7251.     {
  7252.         try {
  7253.             // if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}Z$/', $startDate)) {
  7254.             //     throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7255.             // }
  7256.             // if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}Z$/', $endDate)) {
  7257.             //     throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7258.             // }
  7259.             if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}(:\d{2}(:\d{2}(\.\d{3})?)?)?Z$/', $startDate)) {
  7260.                 throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7261.             }
  7262.             if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}(:\d{2}(:\d{2}(\.\d{3})?)?)?Z$/', $endDate)) {
  7263.                 throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7264.             }
  7265.             $cacheKey = \App\Lib\Utility::generateKey($startDate, $endDate, $metar, $duration, $parameter);
  7266.             $cachedData = $this->redisCache->get($cacheKey);
  7267.             if ($cachedData !== null && !$genExcel) {
  7268.                 // Return the cached data if available
  7269.                return $cachedData;
  7270.             }
  7271.             if ($genExcel) {
  7272.                 $parameters[] = $parameter;
  7273.             } elseif (!empty($parameter) && !$genExcel) {
  7274.                 $parameters = $parameter;
  7275.             } else {
  7276.                 $parameters = [
  7277.                     't_2m:C',
  7278.                     'wind_speed_10m:kmh',
  7279.                     'wind_dir_10m:d',
  7280.                     'msl_pressure:hPa',
  7281.                     'precip_1h:mm',
  7282.                     'relative_humidity_2m:p',
  7283.                     'visibility:km',
  7284.                     'dew_point_2m:c',
  7285.                     'wind_gusts_10m_1h:kmh',
  7286.                     'ceiling_height_agl:m',
  7287.                     'geopotential_height:m',
  7288.                     't_min_2m_24h:C',
  7289.                     't_max_2m_24h:C',
  7290.                     'precip_24h:mm',
  7291.                     'total_cloud_cover:octas',
  7292.                     'wind_speed_10m:kn',
  7293.                     'wind_gusts_10m_1h:kn',
  7294.                 ];
  7295.             }
  7296.     
  7297.             $timeResolutions = [
  7298.                 '_24h' => '+1 day',
  7299.                 '_12h' => '+12 hours',
  7300.                 '_6h' => '+6 hours',
  7301.                 '_3h' => '+3 hours',
  7302.                 '_1h' => '+1 hour'
  7303.             ];
  7304.     
  7305.             $adjustedParameters = [];
  7306.             $nonAdjustedParameters = [];
  7307.     
  7308.             foreach ($parameters as $parameter) {
  7309.                 $matched = false;
  7310.                 foreach ($timeResolutions as $key => $adjustment) {
  7311.                     if (strpos($parameter, $key) !== false) {
  7312.                         $matched = true;
  7313.                         $adjustedParameters[$adjustment][] = $parameter;
  7314.                         break;
  7315.                     }
  7316.                 }
  7317.                 if (!$matched) {
  7318.                     $nonAdjustedParameters[] = $parameter;
  7319.                 }
  7320.             }
  7321.             // Construct the URL
  7322.             // $url = "{$this->apiBaseUrl}/{$startDate}--{$endDate}:{$duration}/t_2m:C,wind_speed_10m:kmh,wind_dir_10m:d,sfs_pressure:hPa,precip_10min:mm,relative_humidity_2m:p,visibility:km,dew_point_2m:c,wind_gusts_10m_1h:kmh,ceiling_height_agl:m,geopotential_height:m,t_min_2m_24h:C,t_max_2m_24h:C,precip_24h:mm,total_cloud_cover:octas/metar_{$metar}/json?source=mix-obs&on_invalid=fill_with_invalid";
  7323.             $dataFinal = [
  7324.                 'version' => null,
  7325.                 'user' => null,
  7326.                 'dateGenerated' => null,
  7327.                 'status' => null,
  7328.                 'data' => []
  7329.             ];
  7330.     
  7331.             foreach ($adjustedParameters as $adjustment => $params) {
  7332.                 $adjustedStartDate = (new \DateTime($startDate))->format('Y-m-d\TH:i:s.v\Z');
  7333.                 $adjustedEndDate = (new \DateTime($endDate))->format('Y-m-d\TH:i:s.v\Z');
  7334.                 $data = $this->fetchMetarData($adjustedStartDate, $adjustedEndDate, $metar, $duration, $params);
  7335.                 // Revert dates to original range
  7336.                 if (isset($data['data']) && is_array($data['data'])) {
  7337.     
  7338.                     foreach ($data['data'] as &$datum) {
  7339.     
  7340.                         if (isset($datum['coordinates'][0]['dates']) && is_array($datum['coordinates'][0]['dates'])) {
  7341.                             foreach ($datum['coordinates'][0]['dates'] as &$date) {
  7342.                                 if (isset($date['date'])) {
  7343.                                     $date['date'] = (new \DateTime($date['date']))
  7344.                                         ->modify('-' . ltrim($adjustment, '+'))
  7345.                                         ->format('Y-m-d\TH:i:s.v\Z');
  7346.                                 }
  7347.                             }
  7348.                         }
  7349.                     }
  7350.                 } else {
  7351.                     $data['data'] = []; // Ensure 'data' exists
  7352.                 }
  7353.     
  7354.                 // Merge into $dataFinal
  7355.                 if (empty($dataFinal['version'])) {
  7356.                     $dataFinal['version'] = $data['version'] ?? null;
  7357.                     $dataFinal['user'] = $data['user'] ?? null;
  7358.                     $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7359.                     $dataFinal['status'] = $data['status'] ?? null;
  7360.                 }
  7361.     
  7362.                 if (isset($data['data']) && is_array($data['data'])) {
  7363.                     $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7364.                 }
  7365.             }
  7366.             if (!empty($nonAdjustedParameters)) {
  7367.                 $data = $this->fetchMetarData($startDate, $endDate, $metar, $duration, $nonAdjustedParameters);
  7368.                 if (isset($data['data']) && is_array($data['data'])) {
  7369.                     $dataFinal['version'] = $data['version'] ?? null;
  7370.                     $dataFinal['user'] = $data['user'] ?? null;
  7371.                     $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7372.                     $dataFinal['status'] = $data['status'] ?? null;
  7373.                     $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7374.                 }
  7375.             }
  7376.     
  7377.             // Reorder data based on parameters
  7378.             $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  7379.                 ? $this->orderResults($dataFinal['data'], $parameters)
  7380.                 : [];
  7381.     
  7382.     
  7383.             if (strpos($metar, ',') === false) {
  7384.     
  7385.                 //get station name and alternative id
  7386.                 if (count($dataFinal['data']) > 0) {
  7387.                     $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7388.                     $dataFinal['data'] = $metarData;
  7389.                 }
  7390.             }
  7391.             if ($genExcel) {
  7392.                 $csvData[] = ['Station Name', 'Parameter(c)', 'Last Update'];
  7393.                 if (count($dataFinal['data']) > 0) {
  7394.                     foreach ($dataFinal['data'] as $key => $value) {
  7395.                         foreach ($value as $key1 => $value1) {
  7396.                             if (!is_array($value1)) {
  7397.                                 $parameter = $value1;
  7398.                             }
  7399.                             if (is_array($value1)) {
  7400.                                 foreach ($value1 as $key2 => $value2) {
  7401.                                     $station_hash = $value2['station_id'] ?? null;
  7402.                                     $station_name = $value2['station_name'] ?? null;
  7403.                                     $station_id = $value2['station_alternativeIds'] ?? null;
  7404.                                     if (is_array($value2['dates'])) {
  7405.                                         foreach ($value2['dates'] as $key3 => $value3) {
  7406.                                             $date  = $value3['date'];
  7407.                                             $value = $value3['value'];
  7408.                                             $csvData[] = [$station_name, $value == '-999' ? 'N/A' : $value, $date];
  7409.                                         }
  7410.                                     }
  7411.                                 }
  7412.                             }
  7413.                         }
  7414.                     }
  7415.                 }
  7416.                 $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/metar_station_weather_data.xlsx");
  7417.                 if ($xlsxReport !== null) {
  7418.                     $xlsxReport->delete();
  7419.                 }
  7420.                 $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "metar_station_weather_data", true, 'StationCsv');
  7421.                 return $excelData;
  7422.             }
  7423.             // Set the data to Redis cache
  7424.             $this->redisCache->set($cacheKey, $dataFinal);
  7425.             return $dataFinal;
  7426.         } catch (RequestException $e) {
  7427.             throw new \Exception($e->getMessage());
  7428.         } catch (\Exception $e) {
  7429.             throw new \Exception($e->getMessage());
  7430.         }
  7431.     }
  7432.     private function fetchMetarData($startDate, $endDate, $metar, $duration, $parameters)
  7433.     {
  7434.         $dataFinal = [];
  7435.             while (!empty($parameters)) {
  7436.                 $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  7437.                 $batchQueryString = implode(',', $batchParameters);
  7438.                 $url = sprintf(
  7439.                     '%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid&use_decluttered=true',
  7440.                     $this->apiBaseUrl,
  7441.                     $startDate,
  7442.                     $endDate,
  7443.                     $duration,
  7444.                     $batchQueryString,
  7445.                     $metar
  7446.     
  7447.                 );
  7448.                 $client = new Client(['verify' => false]);
  7449.                 $response = $client->request('GET', $url, [
  7450.                     'auth' => [$this->username, $this->password],
  7451.                 ]);
  7452.                 $statusCode = $response->getStatusCode();
  7453.                 $data = json_decode($response->getBody(), true);
  7454.                 if ($statusCode != 200) {
  7455.                     return $this->createErrorResponse($statusCode);
  7456.                 }
  7457.                 // Merge data from the current API call into the final data
  7458.                 $dataFinal['version'] = $data['version'];
  7459.                 $dataFinal['user'] = $data['user'];
  7460.                 $dataFinal['dateGenerated'] = $data['dateGenerated'];
  7461.                 $dataFinal['status'] = $data['status'];
  7462.                 $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  7463.             }
  7464.     
  7465.             // Check if there is no comma in $metar
  7466.     
  7467.         return $dataFinal;
  7468.     }
  7471.     public function getWeatherStationDataByHashId($metarData)
  7472.     {
  7473.         $response = [];
  7475.         foreach ($metarData as &$metarParam) {
  7476.             if (count($metarParam['coordinates']) > 0) {
  7477.                 foreach ($metarParam['coordinates'] as &$coordinates) {
  7478.                     $stationData = \Pimcore\Model\DataObject\WeatherStations::getByHash($coordinates['station_id'], true);
  7480.                     if ($stationData) {
  7481.                         $newData = [
  7482.                             'station_name' => $stationData->getName(),
  7483.                             'station_name_ar' => $stationData->getName('ar'),
  7484.                             'station_wmo_id' => $stationData->getWmoId(),
  7485.                             'station_alternativeIds' => $stationData->getAlternativeIds(),
  7486.                         ];
  7488.                         // Append the new data to the existing coordinates without reindexing
  7489.                         $coordinates += $newData;
  7490.                     }
  7491.                 }
  7492.                 // Reset array keys to be sequential
  7493.                 $metarParam['coordinates'] = array_values($metarParam['coordinates']);
  7494.             }
  7495.         }
  7497.         return $metarData;
  7498.     }
  7499.     // public function getWeatherStatioData($startDate, $endDate, $parameters, $hash, $genExcel, $translator, $interval = 'PT24H')
  7500.     // {
  7501.     //     try {
  7502.     //         if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7503.     //             throw new \InvalidArgumentException($translator->trans('invalid_start_date_format'));
  7504.     //         }
  7505.     //         if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7506.     //             throw new \InvalidArgumentException($translator->trans('invalid_end_date_format'));
  7507.     //         }
  7508.     //         $cacheKey = \App\Lib\Utility::generateKey($startDate, $endDate, $parameters, $hash);
  7509.     //         $cachedData = $this->redisCache->get($cacheKey);
  7511.     //         if ($cachedData !== null && !$genExcel) {
  7512.     //             // Return the cached data if available
  7513.     //             return $cachedData;
  7514.     //         }
  7515.     //         $dataFinal = [];
  7516.     //         while (!empty($parameters)) {
  7517.     //             $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  7518.     //             $batchQueryString = implode(',', $batchParameters);
  7519.     //             $url = sprintf(
  7520.     //                 "%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid",
  7521.     //                 $this->apiBaseUrl,
  7522.     //                 $startDate,
  7523.     //                 $endDate,
  7524.     //                 $interval,
  7525.     //                 $batchQueryString,
  7526.     //                 $hash
  7527.     //             );
  7528.     //             $client = new Client(['verify' => false]);
  7529.     //             $response = $client->request('GET', $url, [
  7530.     //                 'auth' => [$this->username, $this->password],
  7531.     //             ]);
  7532.     //             $statusCode = $response->getStatusCode();
  7533.     //             $data = json_decode($response->getBody(), true);
  7534.     //             if ($statusCode != 200) {
  7535.     //                 return $this->createErrorResponse($statusCode);
  7536.     //             }
  7537.     //             // Merge data from the current API call into the final data
  7538.     //             $dataFinal['version'] = $data['version'];
  7539.     //             $dataFinal['user'] = $data['user'];
  7540.     //             $dataFinal['dateGenerated'] = $data['dateGenerated'];
  7541.     //             $dataFinal['status'] = $data['status'];
  7542.     //             $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  7543.     //         }
  7544.     //         if (count($dataFinal['data']) > 0) {
  7545.     //             $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7546.     //             $dataFinal['data'] = $metarData;
  7547.     //         }
  7548.     //         if ($genExcel) {
  7549.     //             $csvData[] = ['parameter', 'station id', 'station name', 'date', 'value'];
  7550.     //             if (count($dataFinal['data']) > 0) {
  7551.     //                 foreach ($dataFinal['data'] as $key => $value) {
  7552.     //                     foreach ($value as $key1 => $value1) {
  7553.     //                         if (!is_array($value1)) {
  7554.     //                             $parameter = $value1;
  7555.     //                         }
  7556.     //                         if (is_array($value1)) {
  7557.     //                             foreach ($value1 as $key2 => $value2) {
  7558.     //                                 $station_hash = $value2['station_id'];
  7559.     //                                 $station_name = $value2['station_name'];
  7560.     //                                 $station_id = $value2['station_alternativeIds'];
  7561.     //                                 if (is_array($value2['dates'])) {
  7562.     //                                     foreach ($value2['dates'] as $key3 => $value3) {
  7563.     //                                         $date  = $value3['date'];
  7564.     //                                         $value = $value3['value'];
  7565.     //                                         $csvData[] = [$parameter, $station_id, $station_name, $date, $value];
  7566.     //                                     }
  7567.     //                                 }
  7568.     //                             }
  7569.     //                         }
  7570.     //                     }
  7571.     //                 }
  7572.     //             }
  7573.     //             $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/historical_weather_data.xlsx");
  7574.     //             if ($xlsxReport !== null) {
  7575.     //                 $xlsxReport->delete();
  7576.     //             }
  7577.     //             $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "historical_weather_data", true, 'StationCsv');
  7578.     //             return $excelData;
  7579.     //         }
  7581.     //         // Set the data to Redis cache
  7582.     //         $this->redisCache->set($cacheKey, $dataFinal);
  7583.     //         return $dataFinal;
  7584.     //     } catch (RequestException $e) {
  7585.     //         throw new \Exception($e->getMessage());
  7586.     //     } catch (\Exception $e) {
  7587.     //         throw new \Exception($e->getMessage());
  7588.     //     }
  7589.     // }
  7593.     public function getWeatherStatioData($startDate, $endDate, $parameters, $hash, $genExcel, $translator, $interval = 'PT24H')
  7594.     {
  7595.         try {
  7596.             if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7597.                 throw new \InvalidArgumentException($translator->trans('invalid_start_date_format'));
  7598.             }
  7599.             if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $endDate)) {
  7600.                 throw new \InvalidArgumentException($translator->trans('invalid_end_date_format'));
  7601.             }
  7603.             $timeResolutions = [
  7604.                 '_24h' => '+1 day',
  7605.                 '_12h' => '+12 hours',
  7606.                 '_6h' => '+6 hours',
  7607.                 '_3h' => '+3 hours',
  7608.                 '_1h' => '+1 hour'
  7609.             ];
  7611.             $adjustedParameters = [];
  7612.             $nonAdjustedParameters = [];
  7614.             foreach ($parameters as $parameter) {
  7615.                 $matched = false;
  7616.                 foreach ($timeResolutions as $key => $adjustment) {
  7617.                     if (strpos($parameter, $key) !== false) {
  7618.                         $matched = true;
  7619.                         $adjustedParameters[$adjustment][] = $parameter;
  7620.                         break;
  7621.                     }
  7622.                 }
  7623.                 if (!$matched) {
  7624.                     $nonAdjustedParameters[] = $parameter;
  7625.                 }
  7626.             }
  7628.             // Initialize $dataFinal
  7629.             $dataFinal = [
  7630.                 'version' => null,
  7631.                 'user' => null,
  7632.                 'dateGenerated' => null,
  7633.                 'status' => null,
  7634.                 'data' => []
  7635.             ];
  7637.             // Process adjusted parameters
  7638.             foreach ($adjustedParameters as $adjustment => $params) {
  7639.                 $adjustedStartDate = (new \DateTime($startDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7640.                 $adjustedEndDate = (new \DateTime($endDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7641.                 $data = $this->fetchWeatherData($adjustedStartDate, $adjustedEndDate, $params, $hash, $interval);
  7643.                 // Revert dates to original range
  7644.                 if (isset($data['data']) && is_array($data['data'])) {
  7646.                     foreach ($data['data'] as &$datum) {
  7648.                         if (isset($datum['coordinates'][0]['dates']) && is_array($datum['coordinates'][0]['dates'])) {
  7649.                             foreach ($datum['coordinates'][0]['dates'] as &$date) {
  7650.                                 if (isset($date['date'])) {
  7651.                                     $date['date'] = (new \DateTime($date['date']))
  7652.                                         ->modify('-' . ltrim($adjustment, '+'))
  7653.                                         ->format('Y-m-d\TH:i:s.v\Z');
  7654.                                 }
  7655.                             }
  7656.                         }
  7657.                     }
  7658.                 } else {
  7659.                     $data['data'] = []; // Ensure 'data' exists
  7660.                 }
  7662.                 // Merge into $dataFinal
  7663.                 if (empty($dataFinal['version'])) {
  7664.                     $dataFinal['version'] = $data['version'] ?? null;
  7665.                     $dataFinal['user'] = $data['user'] ?? null;
  7666.                     $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7667.                     $dataFinal['status'] = $data['status'] ?? null;
  7668.                 }
  7670.                 if (isset($data['data']) && is_array($data['data'])) {
  7671.                     $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7672.                 }
  7673.             }
  7675.             // Process non-adjusted parameters
  7676.             if (!empty($nonAdjustedParameters)) {
  7677.                 $data = $this->fetchWeatherData($startDate, $endDate, $nonAdjustedParameters, $hash, $interval);
  7679.                 if (isset($data['data']) && is_array($data['data'])) {
  7680.                     $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7681.                 }
  7682.             }
  7684.             // Reorder data based on parameters
  7685.             $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  7686.                 ? $this->orderResults($dataFinal['data'], $parameters)
  7687.                 : [];
  7690.             if (count($dataFinal['data']) > 0) {
  7691.                 $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7692.                 $dataFinal['data'] = $metarData;
  7693.             }
  7695.             if ($genExcel) {
  7696.                 return $this->generateExcel($dataFinal);
  7697.             }
  7699.             return $dataFinal;
  7700.         } catch (RequestException $e) {
  7701.             throw new \Exception($e->getMessage());
  7702.         } catch (\Exception $e) {
  7703.             throw new \Exception($e->getMessage());
  7704.         }
  7705.     }
  7707.     private function fetchWeatherData($startDate, $endDate, $parameters, $hash, $interval)
  7708.     {
  7709.         $dataFinal = [];
  7710.         while (!empty($parameters)) {
  7712.             $batchParameters = array_splice($parameters, 0, 10);
  7713.             $batchQueryString = implode(',', $batchParameters);
  7714.             $url = sprintf(
  7715.                 "%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid&use_decluttered=true",
  7716.                 $this->apiBaseUrl,
  7717.                 $startDate,
  7718.                 $endDate,
  7719.                 $interval,
  7720.                 $batchQueryString,
  7721.                 $hash
  7722.             );
  7724.             $client = new Client(['verify' => false]);
  7725.             $response = $client->request('GET', $url, [
  7726.                 'auth' => [$this->username, $this->password],
  7727.             ]);
  7728.             if ($response->getStatusCode() != 200) {
  7729.                 throw new \Exception("Failed to fetch data from API");
  7730.             }
  7731.             $data = json_decode($response->getBody(), true);
  7732.             $dataFinal = array_merge_recursive($dataFinal, $data);
  7733.         }
  7734.         return $dataFinal;
  7735.     }
  7737.     private function generateExcel($data)
  7738.     {
  7739.         $csvData[] = ['parameter', 'station id', 'station name', 'date', 'value'];
  7740.         if (count($data['data']) > 0) {
  7741.             foreach ($data['data'] as $key => $value) {
  7742.                 foreach ($value as $key1 => $value1) {
  7743.                     if (!is_array($value1)) {
  7744.                         $parameter = $value1;
  7745.                     }
  7746.                     if (is_array($value1)) {
  7747.                         foreach ($value1 as $key2 => $value2) {
  7748.                             $station_hash = $value2['station_id'];
  7749.                             $station_name = $value2['station_name'];
  7750.                             $station_id = $value2['station_alternativeIds'];
  7751.                             if (is_array($value2['dates'])) {
  7752.                                 foreach ($value2['dates'] as $key3 => $value3) {
  7753.                                     $date  = $value3['date'];
  7754.                                     $value = $value3['value'];
  7755.                                     $csvData[] = [$parameter, $station_id, $station_name, $date, $value];
  7756.                                 }
  7757.                             }
  7758.                         }
  7759.                     }
  7760.                 }
  7761.             }
  7762.         }
  7763.         $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/historical_weather_data.xlsx");
  7764.         if ($xlsxReport !== null) {
  7765.             $xlsxReport->delete();
  7766.         }
  7767.         $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "historical_weather_data", true, 'StationCsv');
  7768.         return $excelData;
  7769.     }
  7771.     private function orderResults($data, $parameters)
  7772.     {
  7774.         $orderedResults = [];
  7775.         foreach ($parameters as $parameter) {
  7776.             foreach ($data as $key => $item) {
  7777.                 if ($item['parameter'] === $parameter) {
  7778.                     $orderedResults[] = $item;
  7779.                     break;
  7780.                 }
  7781.             }
  7782.         }
  7783.         return $orderedResults;
  7784.     }
  7787.     // Assuming $data1 and $data2 contain the response data from URL1 and URL2 respectively
  7788.     // and that the relevant date fields in these responses are in a format that can be converted to a timestamp
  7790.     function adjustResponseDates(&$data, $hours)
  7791. {
  7792.     error_log(print_r($data, true)); // Log the initial data
  7794.     if ($hours == 24) {
  7795.         $timeAdjustment = '-1 day';
  7796.     } elseif ($hours == 1) {
  7797.         $timeAdjustment = '-1 hour';
  7798.     } elseif ($hours == 12) {
  7799.         $timeAdjustment = '-12 hour';
  7800.     } else {
  7801.         $timeAdjustment = '';
  7802.     }
  7804.     foreach ($data as &$parameter) { // Iterate through each parameter
  7805.         if ($timeAdjustment && isset($parameter['coordinates'])) {
  7806.             foreach ($parameter['coordinates'] as $coordKey => $coordinate) {
  7807.                 if (isset($coordinate['dates']) && is_array($coordinate['dates'])) {
  7808.                     foreach ($coordinate['dates'] as $dateKey => $dateInfo) {
  7809.                         if (isset($dateInfo['date'])) {
  7810.                             // Create DateTime object with UTC timezone
  7811.                             $date = new DateTime($dateInfo['date'], new DateTimeZone('UTC'));
  7813.                             // Apply time adjustment
  7814.                             $date->modify($timeAdjustment);
  7816.                             // Format adjusted date in UTC
  7817.                             $adjustedDate = $date->format('Y-m-d\TH:i:s.v\Z');
  7819.                             // Update the date in the data
  7820.                             $parameter['coordinates'][$coordKey]['dates'][$dateKey]['date'] = $adjustedDate;
  7822.                             // Log the adjusted date
  7823.                             error_log("Adjusted Date: " . $adjustedDate);
  7824.                         }
  7825.                     }
  7826.                 }
  7827.             }
  7828.         }
  7829.     }
  7830.   
  7831.     unset($parameter); // Break the reference with the last element
  7832.     error_log("Final Data: " . print_r($data, true)); // Log the final modified data
  7833. }
  7834. }