//===----------------------------------------------------------------------===
//
// This source file is part of the AmiiboService open source project
//
// Copyright (c) 2024-2025 Röck+Cöde VoF. and the AmiiboAPI project authors
// Licensed under the EUPL 1.2 or later.
//
// See LICENSE for license information
// See CONTRIBUTORS for the list of AmiiboAPI project authors
//
//===----------------------------------------------------------------------===

import Foundation
import OpenAPIRuntime
import OpenAPIURLSession

/// A type that implements a live client to the online service.
public struct AmiiboLiveClient: Sendable {
    
    // MARK: Properties
    
    /// A client generated by the `OpenAPIRuntime` library.
    private let client: Client
    
    // MARK: Initializers
    
    /// Initializes this client.
    /// - Parameter transport: A transport that performs HTTP operations.
    public init(transport: any ClientTransport = URLSessionTransport()) {
        self.client = .init(
            // The force unwrapping implemented below assumes that the server definition from the OpenAPI specification is correct.
            serverURL: try! Servers.Server1.url(),
            configuration: .init(dateTranscoder: ISOTimestampTranscoder()),
            transport: transport
        )
    }
    
}

// MARK: - AmiiboClient
// TODO: Remove the documentation from the functions inside the following extension as the `--enable-inherited-docs` flag when generating DocC documentation is not working as intended (?).

extension AmiiboLiveClient: AmiiboClient {

    // MARK: Functions
    
#if swift(>=6.0)
    /// Gets a list of amiibo items based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo items.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiibos(
        by filter: AmiiboFilter
    ) async throws(AmiiboServiceError) -> [Amiibo] {
        try await fetchAmiibos(filter)
    }

    /// Gets a list of amiibo series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo series.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiiboSeries(
        by filter: AmiiboSeriesFilter
    ) async throws(AmiiboServiceError) -> [AmiiboSeries] {
        try await fetchAmiiboSeries(filter)
    }
 
    /// Gets a list of amiibo types based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo types.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiiboTypes(
        by filter: AmiiboTypeFilter
    ) async throws(AmiiboServiceError) -> [AmiiboType] {
        try await fetchAmiiboTypes(filter)
    }

    /// Gets a list of game characters based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered game characters.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getGameCharacters(
        by filter: GameCharacterFilter
    ) async throws(AmiiboServiceError) -> [GameCharacter] {
        try await fetchGameCharacters(filter)
    }

    /// Gets a list of game series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered game series.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getGameSeries(
        by filter: GameSeriesFilter
    ) async throws(AmiiboServiceError) -> [GameSeries] {
        try await fetchGameSeries(filter)
    }

    /// Gets the date when the data was last updated.
    /// - Returns: A last updated date.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getLastUpdated() async throws(AmiiboServiceError) -> Date {
        try await fetchLastUpdated()
    }
#else
    /// Gets a list of amiibo items based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo items.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiibos(
        by filter: AmiiboFilter
    ) async throws -> [Amiibo] {
        try await fetchAmiibos(filter)
    }
    
    /// Gets a list of amiibo series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo series.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiiboSeries(
        by filter: AmiiboSeriesFilter
    ) async throws -> [AmiiboSeries] {
        try await fetchAmiiboSeries(filter)
    }
    
    /// Gets a list of amiibo types based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered amiibo types.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getAmiiboTypes(
        by filter: AmiiboTypeFilter
    ) async throws -> [AmiiboType] {
        try await fetchAmiiboTypes(filter)
    }
    
    /// Gets a list of game characters based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered game characters.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getGameCharacters(
        by filter: GameCharacterFilter
    ) async throws -> [GameCharacter] {
        try await fetchGameCharacters(filter)
    }
    
    /// Gets a list of game series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of filtered game series.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getGameSeries(
        by filter: GameSeriesFilter
    ) async throws -> [GameSeries] {
        try await fetchGameSeries(filter)
    }
    
    /// Gets the date when the data was last updated.
    /// - Returns: A last updated date.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    public func getLastUpdated() async throws -> Date {
        try await fetchLastUpdated()
    }
#endif
    
}

// MARK: - Helpers

private extension AmiiboLiveClient {
    
    // MARK: Functions
    
    /// Fetches a list of amiibo items based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of fetched amiibo items filtered, if requested.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchAmiibos(
        _ filter: AmiiboFilter
    ) async throws -> [Amiibo] {
        let response: Operations.getAmiibos.Output
        
        do {
            response = try await client.getAmiibos(.init(query: .init(
                amiiboSeries: filter.series,
                character: filter.gameCharacter,
                gameseries: filter.gameSeries,
                head: filter.head,
                id: filter.identifier,
                name: filter.name,
                showgames: filter.showGames,
                showusage: filter.showUsage,
                tail: filter.tail,
                _type: filter.type
            )))
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return map(output)
            }
        case .badRequest:
            throw AmiiboServiceError.badRequest
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }

    /// Fetches a list of amiibo series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of fetched amiibo series filtered, if requested.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchAmiiboSeries(
        _ filter: AmiiboSeriesFilter
    ) async throws -> [AmiiboSeries] {
        let response: Operations.getAmiiboSeries.Output
        
        do {
            response = try await client.getAmiiboSeries(.init(query: .init(
                key: filter.key,
                name: filter.name
            )))
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return map(output)
            }
        case .badRequest:
            throw AmiiboServiceError.badRequest
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
        case .notFound:
            throw AmiiboServiceError.notFound
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    /// Fetches a list of amiibo types based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of fetched amiibo types filtered, if requested.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchAmiiboTypes(
        _ filter: AmiiboTypeFilter
    ) async throws -> [AmiiboType] {
        let response: Operations.getAmiiboTypes.Output
        
        do {
            response = try await client.getAmiiboTypes(.init(query: .init(
                key: filter.key,
                name: filter.name
            )))
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return map(output)
            }
        case .badRequest:
            throw AmiiboServiceError.badRequest
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
        case .notFound:
            throw AmiiboServiceError.notFound
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    /// Fetches a list of game characters based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of fetched game characters filtered, if requested.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchGameCharacters(
        _ filter: GameCharacterFilter
    ) async throws -> [GameCharacter] {
        let response: Operations.getGameCharacters.Output
        
        do {
            response = try await client.getGameCharacters(.init(query: .init(
                key: filter.key,
                name: filter.name
            )))
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return map(output)
            }
        case .badRequest:
            throw AmiiboServiceError.badRequest
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
        case .notFound:
            throw AmiiboServiceError.notFound
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    /// Fetches a list of game series based on a given filter.
    /// - Parameter filter: A filter to remove unwanted items from the result.
    /// - Returns: A list of fetched game series filtered, if requested.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchGameSeries(
        _ filter: GameSeriesFilter
    ) async throws -> [GameSeries] {
        let response: Operations.getGameSeries.Output
        
        do {
            response = try await client.getGameSeries(.init(query: .init(
                key: filter.key,
                name: filter.name
            )))
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return map(output)
            }
        case .badRequest:
            throw AmiiboServiceError.badRequest
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
        case .notFound:
            throw AmiiboServiceError.notFound
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    /// Fetches the date when the data was last updated.
    /// - Returns: A fetched last updated date.
    /// - Throws: An ``AmiiboServiceError`` error in case some issue is encountered while generating the result.
    func fetchLastUpdated() async throws -> Date {
        let response: Operations.getLastUpdated.Output
        
        do {
            response = try await client.getLastUpdated()
        } catch {
            try handle(error: error)
        }
        
        switch response {
        case let .ok(ok):
            switch ok.body {
            case let .json(output):
                return output.lastUpdated
            }
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    /// Maps a given error to a `AmiiboServiceError` error.
    /// - Parameter error: An error to map.
    /// - Throws: An ``AmiiboServiceError`` error.
    func handle(error: any Error) throws -> Never {
        switch error {
        case is CancellationError:
            throw AmiiboServiceError.cancelled
        case let clientError as ClientError:
            switch clientError.underlyingError {
            case is DecodingError:
                throw AmiiboServiceError.decoding
            case let urlError as URLError:
                switch urlError.code {
                case .cannotFindHost,
                     .cannotConnectToHost,
                     .dnsLookupFailed,
                     .networkConnectionLost,
                     .notConnectedToInternet,
                     .timedOut:
                    throw AmiiboServiceError.notAvailable
                default:
                    throw AmiiboServiceError.unknown
                }
            default:
                throw AmiiboServiceError.unknown
            }
        default:
            throw AmiiboServiceError.unknown
        }
    }
    
    /// Retrieves a list of amiibo items from a wrapper container.
    /// - Parameter wrapper: A wrapper container that either has an object or a list of items.
    /// - Returns: A list of amiibo items, sorted by identifiers.
    func map(
        _ wrapper: Components.Schemas.AmiiboWrapper
    ) -> [Amiibo] {
        switch wrapper.amiibo {
        case let .Amiibo(object):
            return [Amiibo(object)]
        case let .AmiiboList(list):
            return list
                .map { Amiibo($0) }
                .sorted { $0.identifier < $1.identifier }
        }
    }
    
    /// Retrieves a list of items that conforms to the `KeyNameModel` protocol from a wrapper container.
    /// - Parameter wrapper: A wrapper container that either has an object or a list of items.
    /// - Returns: A list of items that conforms to the `KeyNameModel` protocol, sorted by keys.
    func map<Model: KeyNameModel>(
        _ wrapper: Components.Schemas.TupleWrapper
    ) -> [Model] {
        switch wrapper.amiibo {
        case let .Tuple(payload):
            return [Model(payload)]
        case let .TupleList(list):
            return list
                .map { Model($0) }
                .sorted { $0.key < $1.key }
        }
    }
    
}