CityWeatherViewModel.swift

//
//  CityWeatherViewModel.swift
//  Pogoda Net
//
//  Created by MAXIM GORNOSTAEV on 2/10/26.
//

import Foundation
import CoreLocation

@MainActor
final class CityWeatherViewModel: NSObject, WeatherViewModelProtocol {

    // MARK: - Output

    var onUpdate: (() -> Void)?
    var onError: ((String) -> Void)?

    // MARK: - State

    private(set) var weather: Weather?
    private(set) var dailyForecast: [DailyForecast] = []
    private(set) var hourlyForecast: [HourlyForecast] = []
    private let city: String?
    private let service: WeatherServiceProtocol
    private var allDailyForecast: [DailyForecast] = []
    private var allHourlyForecast: [HourlyForecast] = []
    private(set) var displayedDaysCount: Int = UserDefaults.standard.integer(forKey: ForecastSettings.daysCountKey)

    // MARK: - Location

    private let locationManager = CLLocationManager()

    private var isUsingLocation: Bool {
        city == nil
    }

    // MARK: - Init (город)

    init(
        city: String,
        service: WeatherServiceProtocol = WeatherService()
    ) {
        self.city = city
        self.service = service
        super.init()
    }

    // MARK: - Init (геолокация)

    init(
        service: WeatherServiceProtocol = WeatherService()
    ) {
        self.city = nil
        self.service = service
        super.init()
        locationManager.delegate = self
    }

    // MARK: - Lifecycle

    func viewDidLoad() {
        let savedCount = UserDefaults.standard.integer(forKey: ForecastSettings.daysCountKey)
        displayedDaysCount = savedCount == 0 ? ForecastSettings.defaultDaysCount : savedCount

        if isUsingLocation {
            requestLocation()
        } else if let city {
            Task { await loadData(for: city) }
        }
    }

    func setDisplayedDaysCount(_ count: Int) {
        displayedDaysCount = count
        dailyForecast = Array(allDailyForecast.prefix(count))
        onUpdate?()
    }

    func reloadData() {
        if isUsingLocation {
            requestLocation()
        } else if let city {
            Task { await loadData(for: city) }
        }
    }

    // MARK: - Private

    private func requestLocation() {
        locationManager.requestWhenInUseAuthorization()
        locationManager.requestLocation()
    }

    private func loadData(for city: String) async {
        do {
            async let cachedCurrent = service.fetchWeather(for: city, forceRefresh: false)
            async let cachedForecast = service.fetchForecast(for: city, forceRefresh: false)
            applyState(weather: try await cachedCurrent, forecast: try await cachedForecast)
            onUpdate?()

            do {
                async let freshCurrent = service.fetchWeather(for: city, forceRefresh: true)
                async let freshForecast = service.fetchForecast(for: city, forceRefresh: true)
                applyState(weather: try await freshCurrent, forecast: try await freshForecast)
                onUpdate?()
            } catch {
                // Если сеть недоступна, остаёмся на уже показанном кэше.
            }
        } catch {
            onError?("Не удалось загрузить погоду")
        }
    }

    private func loadData(for coordinate: CLLocationCoordinate2D) async {
        do {
            async let cachedCurrent = service.fetchWeather(
                latitude: coordinate.latitude,
                longitude: coordinate.longitude,
                forceRefresh: false
            )
            async let cachedForecast = service.fetchForecast(
                latitude: coordinate.latitude,
                longitude: coordinate.longitude,
                forceRefresh: false
            )
            applyState(weather: try await cachedCurrent, forecast: try await cachedForecast)
            onUpdate?()

            do {
                async let freshCurrent = service.fetchWeather(
                    latitude: coordinate.latitude,
                    longitude: coordinate.longitude,
                    forceRefresh: true
                )
                async let freshForecast = service.fetchForecast(
                    latitude: coordinate.latitude,
                    longitude: coordinate.longitude,
                    forceRefresh: true
                )
                applyState(weather: try await freshCurrent, forecast: try await freshForecast)
                onUpdate?()
            } catch {
                // Если сеть недоступна, остаёмся на уже показанном кэше.
            }
        } catch {
            onError?("Не удалось загрузить погоду")
        }
    }

    private func applyState(
        weather: Weather,
        forecast: (daily: [DailyForecast], hourly: [HourlyForecast])
    ) {
        self.weather = weather
        allDailyForecast = forecast.daily
        allHourlyForecast = forecast.hourly
        dailyForecast = Array(allDailyForecast.prefix(displayedDaysCount))
        hourlyForecast = allHourlyForecast
    }

    // MARK: - Computed

    var cityName: String {
        weather?.city ?? (city ?? "Текущая локация")
    }

    var temperatureText: String {
        guard let temp = weather?.temperature else { return "—" }
        return "\(temp)°C"
    }

    var descriptionText: String {
        weather?.description ?? "Загрузка..."
    }
}

// MARK: - CLLocationManagerDelegate

extension CityWeatherViewModel: CLLocationManagerDelegate {

    func locationManager(
        _ manager: CLLocationManager,
        didUpdateLocations locations: [CLLocation]
    ) {
        guard let location = locations.first else { return }

        Task {
            await loadData(for: location.coordinate)
        }
    }

    func locationManager(
        _ manager: CLLocationManager,
        didFailWithError error: Error
    ) {
        onError?("Не удалось определить местоположение")
    }
}