<?php

namespace App\Services;

use App\Models\Product;
use Carbon\Carbon;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class ZaarboxPriceService
{
    public const CACHE_KEY = 'zaarbox_gold_prices';

    private const CACHE_TTL_MINUTES = 35;

    private const DEFAULT_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],
    ];

    public function __construct(private ConfigService $config)
    {
    }

    public function isEnabled(): bool
    {
        return $this->config->usesZaarboxPricing();
    }

    public function apiUrl(): string
    {
        $url = trim((string) $this->config->getString(
            'zaarbox_api_url',
            (string) config('price_providers.zaarbox_api_url', 'https://price.zaarbox.ir/api/free')
        ));

        return $url !== '' ? $url : 'https://price.zaarbox.ir/api/free';
    }

    /** کلید یا id ردیف در JSON تابلو (settings: zaarbox_price_key) */
    public function priceIdentifier(): string
    {
        return trim((string) $this->config->getString(
            'zaarbox_price_key',
            (string) config('price_providers.zaarbox_price_key', '')
        ));
    }

    /**
     * UUID سری نمودار: settings.chart_id؛ وگرنه پیش‌فرض گلد علی.
     * GET https://price.zaarbox.ir/api/history/{id}
     */
    public function historyId(): string
    {
        $chartId = $this->config->getString('chart_id', '');
        if ($chartId !== '') {
            return $chartId;
        }

        $legacy = $this->config->getString(
            'zaarbox_gold_history_id',
            (string) config('price_providers.zaarbox_gold_history_id', '')
        );
        if ($legacy !== '') {
            return $legacy;
        }

        return self::DEFAULT_HISTORY_ID;
    }

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

    /**
     * @return array{DAILY: array<int, array{timestamp: int, value: int}>, WEEKLY: array, MONTHLY: array}
     */
    public function getAllPrices(): array
    {
        $cached = Cache::get($this->cacheKey());

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

        return $this->refreshCache();
    }

    /**
     * @return array{DAILY: array<int, array{timestamp: int, value: int}>, WEEKLY: array, MONTHLY: array}
     */
    public function refreshCache(): array
    {
        $prices = $this->fetchChartPrices();

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

        return $prices;
    }

    /**
     * @return array{price: int, order_price: int, raw: array<string, mixed>|null}
     */
    public function fetchPrice(): array
    {
        $empty = ['price' => 0, 'order_price' => 0, 'raw' => null];
        $identifier = $this->priceIdentifier();
        if ($identifier === '') {
            return $empty;
        }

        try {
            $prices = Http::withoutVerifying()
                ->timeout(20)
                ->get($this->apiUrl())
                ->json();

            if (!is_array($prices)) {
                return $empty;
            }

            $row = $this->findRow(collect($prices), $identifier);
            if (empty($row)) {
                Log::warning('Zaarbox price row not found', [
                    'identifier' => $identifier,
                    'api' => $this->apiUrl(),
                ]);

                return $empty;
            }

            $base = (float) ($row['price'] ?? 0);
            $profit = (float) ($row['profit'] ?? 0);
            $orderPrice = (int) round($base + $profit);

            return ['price' => $orderPrice, 'order_price' => $orderPrice, 'raw' => $row];
        } catch (\Throwable $e) {
            Log::warning('Zaarbox price fetch failed', ['message' => $e->getMessage()]);

            return $empty;
        }
    }

    /** @return array<int, array<string, mixed>>|null */
    public function fetchPriceList(): ?array
    {
        try {
            $prices = Http::withoutVerifying()
                ->timeout(20)
                ->get($this->apiUrl())
                ->json();

            return is_array($prices) ? $prices : null;
        } catch (\Throwable $e) {
            Log::warning('Zaarbox price list fetch failed', ['message' => $e->getMessage()]);

            return null;
        }
    }

    /**
     * @return array<int, array{key: string, name: string, id: string, category: string, active: bool}>
     */
    public function listProductOptions(): array
    {
        $prices = $this->fetchPriceList();
        if ($prices === null) {
            return [];
        }

        return collect($prices)
            ->map(function ($row) {
                $row = is_array($row) ? $row : (array) $row;

                return [
                    'key' => trim((string) ($row['key'] ?? '')),
                    'name' => trim((string) ($row['name'] ?? '')),
                    'id' => trim((string) ($row['id'] ?? '')),
                    'category' => trim((string) ($row['category'] ?? '')),
                    'active' => (bool) ($row['active'] ?? false),
                ];
            })
            ->filter(fn (array $row) => $row['key'] !== '')
            ->sortBy('name', SORT_NATURAL | SORT_FLAG_CASE)
            ->values()
            ->all();
    }

    /**
     * @return array{order_price: int, raw: array<string, mixed>|null}
     */
    public function fetchLiveOrderPrice(?string $readingMethod, ?string $apiUrl = null): array
    {
        $empty = ['order_price' => 0, 'raw' => null];
        $readingMethod = trim((string) $readingMethod);
        if ($readingMethod === '') {
            return $empty;
        }

        try {
            $url = $apiUrl ?: $this->apiUrl();
            $prices = Http::withoutVerifying()->timeout(20)->get($url)->json();
            if (!is_array($prices)) {
                return $empty;
            }

            $row = $this->findRow(collect($prices), $readingMethod);
            if (empty($row)) {
                return $empty;
            }

            $orderPrice = (int) round((float) ($row['price'] ?? 0) + (float) ($row['profit'] ?? 0));

            return ['order_price' => $orderPrice, 'raw' => $row];
        } catch (\Throwable $e) {
            Log::warning('Zaarbox live board price fetch failed', ['message' => $e->getMessage()]);

            return $empty;
        }
    }

    public function syncProductsFromApi(): bool
    {
        $prices = $this->fetchPriceList();
        if ($prices === null) {
            return false;
        }

        $products = Product::with([])->whereNotNull('reading_method')->get();
        $collection = collect($prices);
        $copper = null;
        $dollar = null;

        foreach ($products as $product) {
            $RPrice = $collection->firstWhere('key', $product->reading_method);
            if (empty($RPrice)) {
                continue;
            }

            if (($RPrice['name'] ?? '') === 'TGJU فلز مس') {
                $copper = ($RPrice['price'] ?? 0) + ($RPrice['profit'] ?? 0);
            }
            if (($RPrice['name'] ?? '') === 'TGJU دلار') {
                $dollar = ($RPrice['price'] ?? 0) + ($RPrice['profit'] ?? 0);
            }
            if (($RPrice['name'] ?? '') === 'گلد دات ای از آبشده - رسمی - نقد فردا') {
                $RPrice['price'] = ($RPrice['price'] ?? 0) / 4.3318;
            }

            ProductPriceService::syncFromReference(
                $product,
                (int) $RPrice['price'],
                (int) ($RPrice['profit'] ?? 0)
            );
        }

        if ($copper !== null && $dollar !== null) {
            $cp = ($copper / 1000000) * $dollar;
            $copperProduct = Product::find(33);
            if ($copperProduct) {
                ProductPriceService::syncFromReference($copperProduct, (int) round($cp), 0);
            }
        }

        return true;
    }

    public function syncProductFromApi(Product $product): bool
    {
        if (!Product::hasStoredPriceColumns()) {
            return false;
        }

        if (!$product->reading_method) {
            return false;
        }

        $prices = $this->fetchPriceList();
        if ($prices === null) {
            return false;
        }

        $RPrice = collect($prices)->firstWhere('key', $product->reading_method);
        if (empty($RPrice)) {
            return false;
        }

        if (($RPrice['name'] ?? '') === 'گلد دات ای از آبشده - رسمی - نقد فردا') {
            $RPrice['price'] = ($RPrice['price'] ?? 0) / 4.3318;
        }

        ProductPriceService::syncFromReference(
            $product,
            (int) $RPrice['price'],
            (int) ($RPrice['profit'] ?? 0)
        );

        return true;
    }

    /**
     * @return array{DAILY: array<int, array{timestamp: int, value: int}>, WEEKLY: array, MONTHLY: array}
     */
    private function fetchChartPrices(): 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
    {
        return sprintf(
            'https://price.zaarbox.ir/api/history/%s?start=%s&end=%s&limit=1000000000',
            $this->historyId(),
            $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;
    }

    /**
     * @param array<int, array<string, mixed>> $history
     * @return array<int, array{timestamp: int, value: int}>
     */
    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;
        }
    }

    /**
     * @param Collection<int, array<string, mixed>> $collection
     * @return array<string, mixed>|null
     */
    private function findRow(Collection $collection, string $identifier): ?array
    {
        $row = $collection->firstWhere('key', $identifier);
        if (!empty($row)) {
            return $row;
        }

        $row = $collection->firstWhere('id', $identifier);
        if (!empty($row)) {
            return $row;
        }

        return null;
    }
}