<?php

namespace App\Services;

use Carbon\Carbon;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class ZaarboxPriceService
{
    private const CACHE_KEY_PREFIX = 'zaarbox_gold_prices';

    private const CACHE_TTL_MINUTES = 35;

    private const HISTORY_ID = 'ca3800a0-1f57-3528-b963-178f9168e04f';

    private const PERIODS = [
        'DAILY' => ['hours' => 24, 'intervalMs' => 900000],
        'WEEKLY' => ['hours' => 168, 'intervalMs' => 7200000],
        'MONTHLY' => ['hours' => 720, 'intervalMs' => 28800000],
    ];

    private function config(): ConfigService
    {
        return app(ConfigService::class);
    }

    private function historyId(): string
    {
        $chartId = $this->config()->Config('chart_id');

        return $chartId ?: self::HISTORY_ID;
    }

    private function cacheKey(): string
    {
        return self::CACHE_KEY_PREFIX . ':' . $this->historyId();
    }

    public function getAllPrices(): array
    {
        $cached = Cache::get($this->cacheKey());

        if (is_array($cached) && isset($cached['prices'])) {
            return $cached['prices'];
        }

        return $this->refreshCache();
    }

    public function refreshCache(): array
    {
        $prices = $this->fetchAllPrices();

        Cache::put($this->cacheKey(), [
            'prices' => $prices,
            'refreshed_at' => now()->toIso8601String(),
        ], now()->addMinutes(self::CACHE_TTL_MINUTES));

        return $prices;
    }

    private function fetchAllPrices(): array
    {
        $now = Carbon::now('UTC');
        $prices = [];

        $responses = Http::pool(function ($pool) use ($now) {
            foreach (self::PERIODS as $key => $config) {
                $start = $now->copy()->subHours($config['hours']);
                $pool->as($key)->withHeaders([
                    'Referer' => 'https://tablo.montest.ir/',
                    'User-Agent' => 'Mozilla/5.0',
                ])->get($this->historyUrl($start, $now));
            }
        });

        foreach (self::PERIODS as $key => $config) {
            $response = $responses[$key] ?? null;
            $start = $now->copy()->subHours($config['hours']);

            if (!$response || !$response->successful()) {
                Log::warning('Zaarbox price history fetch failed', [
                    'period' => $key,
                    'status' => $response?->status(),
                ]);
                $prices[$key] = [];
                continue;
            }

            $history = $response->json('history') ?? [];
            $prices[$key] = $this->mapHistory(
                $history,
                $this->toMillis($start),
                $this->toMillis($now),
                $config['intervalMs']
            );
        }

        return $prices;
    }

    private function historyUrl(Carbon $start, Carbon $end): string
    {
        $id = $this->historyId();

        return sprintf(
            'https://price.zaarbox.ir/api/history/%s?start=%s&end=%s&limit=1000000000',
            $id,
            $this->toIso8601($start),
            $this->toIso8601($end)
        );
    }

    private function toIso8601(Carbon $date): string
    {
        return $date->format('Y-m-d\TH:i:s') . '.' . str_pad((string) $date->millisecond, 3, '0', STR_PAD_LEFT) . 'Z';
    }

    private function toMillis(Carbon $date): int
    {
        return ($date->getTimestamp() * 1000) + $date->millisecond;
    }

    private function mapHistory(array $history, int $startMs, int $endMs, int $intervalMs): array
    {
        $points = [];

        foreach ($history as $entry) {
            if (!isset($entry['time'], $entry['price'])) {
                continue;
            }

            $timestamp = $this->parseTimestampMs($entry['time']);
            if ($timestamp === null) {
                continue;
            }

            $points[] = [
                'timestamp' => $timestamp,
                'price' => (int) $entry['price'],
            ];
        }

        usort($points, fn ($a, $b) => $a['timestamp'] <=> $b['timestamp']);

        $firstBucket = (int) (ceil($startMs / $intervalMs) * $intervalMs);
        if ($firstBucket < $startMs) {
            $firstBucket += $intervalMs;
        }

        $result = [];
        $index = 0;
        $lastPoint = null;
        $count = count($points);

        for ($bucket = $firstBucket; $bucket <= $endMs; $bucket += $intervalMs) {
            while ($index < $count && $points[$index]['timestamp'] <= $bucket) {
                $lastPoint = $points[$index];
                $index++;
            }

            if ($lastPoint === null) {
                continue;
            }

            $result[] = [
                'value' => intdiv($lastPoint['price'], 1000),
                'timestamp' => $bucket,
            ];
        }

        return $result;
    }

    private function parseTimestampMs(string $time): ?int
    {
        try {
            return $this->toMillis(Carbon::parse($time)->utc());
        } catch (\Throwable) {
            return null;
        }
    }
}