//===----------------------------------------------------------------------===//
//
// This source file is part of the AmiiboAPI open source project
//
// Copyright (c) 2024 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

public struct AmiiboService {
    
    // MARK: Properties
    
    private let client: Client
    
    // MARK: Initialisers

    public init() throws {
        self.client = try .live
    }

    // MARK: Functions
    
    public func getAmiibos(
        by filter: AmiiboFilter = .init()
    ) async throws -> [Amiibo] {
        let response = try await client.getAmiibos(
            .init(query: .init(
                amiiboSeries: filter.series,
                character: filter.gameCharacter,
                gameseries: filter.gameSeries,
                id: filter.identifier,
                name: filter.name,
                showgames: filter.showGames,
                showusage: filter.showUsage,
                _type: filter.type
            ))
        )
        
        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                switch output.amiibo {
                case let .Amiibo(object):
                    return [.init(object)]

                case let .AmiiboList(list):
                    return list
                        .map { .init($0) }
                        .sorted { $0.identifier < $1.identifier }
                }
            }
            
        case .badRequest:
            throw AmiiboServiceError.badRequest

        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    public func getAmiiboSeries(
        by filter: AmiiboSeriesFilter = .init()
    ) async throws -> [AmiiboSeries] {
        let response = try await client.getAmiiboSeries(
            .init(query: .init(
                key: filter.key,
                name: filter.name
            ))
        )
        
        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                return map(output, to: AmiiboSeries.self)
            }
            
        case .badRequest:
            throw AmiiboServiceError.badRequest
            
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
            
        case .notFound:
            throw AmiiboServiceError.notFound
            
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    public func getAmiiboTypes(
        by filter: AmiiboTypeFilter = .init()
    ) async throws -> [AmiiboType] {
        let response = try await client.getAmiiboTypes(
            .init(query: .init(
                key: filter.key,
                name: filter.name
            ))
        )
        
        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                return map(output, to: AmiiboType.self)
            }
            
        case .badRequest:
            throw AmiiboServiceError.badRequest
            
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
            
        case .notFound:
            throw AmiiboServiceError.notFound

        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    public func getGameCharacters(
        by filter: GameCharacterFilter = .init()
    ) async throws -> [GameCharacter] {
        let response = try await client.getGameCharacters(
            .init(query: .init(
                key: filter.key,
                name: filter.name
            ))
        )
        
        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                return map(output, to: GameCharacter.self)
            }
            
        case .badRequest:
            throw AmiiboServiceError.badRequest
            
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
            
        case .notFound:
            throw AmiiboServiceError.notFound
            
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    public func getGameSeries(
        by filter: GameSeriesFilter = .init()
    ) async throws -> [GameSeries] {
        let response = try await client.getGameSeries(
            .init(query: .init(
                key: filter.key,
                name: filter.name
            ))
        )
        
        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                return map(output, to: GameSeries.self)
            }
            
        case .badRequest:
            throw AmiiboServiceError.badRequest
            
        case .internalServerError:
            throw AmiiboServiceError.notAvailable
            
        case .notFound:
            throw AmiiboServiceError.notFound
            
        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
    public func getLastUpdated() async throws -> Date {
        let response = try await client.getLastUpdated()

        switch response {
        case let .ok(okResponse):
            switch okResponse.body {
            case let .json(output):
                return output.lastUpdated
            }

        case let .undocumented(statusCode, _):
            throw AmiiboServiceError.undocumented(statusCode)
        }
    }
    
}

// MARK: - Helpers

private extension AmiiboService {
    
    // MARK: Functions
    
    func map<Model: KeyNameModel>(
        _ output: Components.Schemas.TupleWrapper,
        to: Model.Type
    ) -> [Model] {
        switch output.amiibo {
        case let .Tuple(payload):
            return [.init(payload)]
            
        case let .TupleList(list):
            return list
                .map { .init($0) }
                .sorted { $0.key < $1.key }
        }
    }
    
}