import Foundation

// sourcery: AutoMockable
// Represents object that is able to log decoding errors in details
protocol DecodingErrorLogging: AnyObject {
    /// This method is used to debug decoding failures
    /// - Parameters:
    ///   - error: Error to log information on
    ///   - type: Type that decoding was attempted for
    func logAdditionalDecodingFailureInfo(with error: Error, for type: Decodable.Type)
}

/// Class that logs error on decoding network models
final class DecodingErrorLogger: DecodingErrorLogging {
    private let jsonDecoder: JSONDecoding
    private let loggerService: Logging

    init(
        jsonDecoder: JSONDecoding = BFJSONDecoder(keyDecodingStrategy: .convertFromSnakeCase),
        loggerService: Logging = NetworkingServiceLocator.logger
    ) {
        self.jsonDecoder = jsonDecoder
        self.loggerService = loggerService
    }

    func logAdditionalDecodingFailureInfo(with error: Error, for type: Decodable.Type) {
        var errorDescription: String?
        var logProperties: [LoggerPropertyKeys: String] = [:]

        if let decodingError = error as? DecodingError {
            switch decodingError {
            case let .dataCorrupted(context):
                // An indication that the data is corrupted or otherwise invalid.
                addContext(context, logProperties: &logProperties)
                errorDescription = LoggerPropertyKeys.dataCorrupted.rawValue
            case let .keyNotFound(key, context):
                // An indication that a keyed decoding container was asked for an entry for the given key,
                // but did not contain one.
                addContext(context, logProperties: &logProperties)
                errorDescription = "Key '\(key)' not found"
            case let .valueNotFound(value, context):
                // An indication that a non-optional value of the given type was expected, but a null value was found.
                addContext(context, logProperties: &logProperties)
                errorDescription = "Value '\(value)' not found"
            case let .typeMismatch(type, context):
                // An indication that a value of the given type could not be decoded because
                // it did not match the type of what was found in the encoded payload.
                addContext(context, logProperties: &logProperties)
                errorDescription = "Type '\(type)' mismatch"
            default: ()
            }
        }
        logProperties[.decodingError] = errorDescription ?? error.localizedDescription
        logProperties[.model] = "\(type)"

        // Log as warning so the information reaches AppCenter Crash reports
        loggerService.log(.warn, .decodingFailure, properties: logProperties)
    }
}

private extension DecodingErrorLogger {
    /// Add Decoding Error context information to the dictionary
    func addContext(
        _ context: DecodingError.Context,
        logProperties: inout [LoggerPropertyKeys: String]
    ) {
        logProperties[.contextProperty] = context.debugDescription
        logProperties[.codingPathProperty] = context.codingPath.debugDescription
        logProperties[.underlyingErrorProperty] = context.underlyingError.debugDescription
    }
}

    public enum Configuration {
        /// Verbose: logs requests/responses to the console based on the associated values.
        case verbose(logRequests: Bool, logResponses: Bool)
        /// Quiet: doesn't log anything.
        case quiet
    }

    /// Configuration options.
    public enum Configuration {
        /// Verbose: logs requests/responses to the console based on the associated values.
        case verbose(
            requestConfiguration: RequestConfiguration,
            responseConfiguration: ResponseConfiguration
        )
        /// Quiet: doesn't log anything.
        case quiet

        public struct RequestConfiguration {
            var logInternalId: Bool
            var logURL: Bool
            var logHTTPMethod: Bool
            var logHTTPHeaders: Bool
            var logHTTPBody: Bool
        }

        public struct ResponseConfiguration {
            var logInternalId: Bool
            var logURL: Bool
            var logStatusCode: Bool
            var logJSONResponse: Bool
            var logExpectedModel: Bool
            var logDecodingResult: Bool
        }
    }

//
//  JSONEncoder+NullCodable.swift
//
//
//  Created by Manu on 17/05/2023.
//  Based on: https://github.com/g-mark/NullCodable

import Foundation

/// Property wrapper that encodes `nil` optional values as `null`
/// when encoded using `JSONEncoder`.
///
/// For example, adding `@NullCodable` like this:
/// ```swift
/// struct Test: Codable {
///     @NullCodable var name: String? = nil
/// }
/// ```
/// will encode as: "{\\"name\\": null}" - as opposed to the default,
/// which is to omit the property from the encoded json, like: "{}".
@propertyWrapper
public struct NullCodable<Wrapped> {
    /// The wrapper value.
    public var wrappedValue: Wrapped?

    /// Initializer.
    public init(wrappedValue: Wrapped?) {
        self.wrappedValue = wrappedValue
    }
}

extension NullCodable: Encodable where Wrapped: Encodable {
    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch wrappedValue {
        case let .some(value):
            try container.encode(value)
        case .none:
            try container.encodeNil()
        }
    }
}

extension NullCodable: Decodable where Wrapped: Decodable {
    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        if !container.decodeNil() {
            wrappedValue = try container.decode(Wrapped.self)
        }
    }
}

extension NullCodable: Equatable where Wrapped: Equatable {}

public extension KeyedDecodingContainer {
    /// Decoding method.
    func decode<Wrapped>(
        _: NullCodable<Wrapped>.Type,
        forKey key: KeyedDecodingContainer<K>.Key
    ) throws -> NullCodable<Wrapped> where Wrapped: Decodable {
        try decodeIfPresent(NullCodable<Wrapped>.self, forKey: key) ?? NullCodable<Wrapped>(wrappedValue: nil)
    }
}

public extension Encodable {
    /// Creates a json dictionary from an Encodable Object
    var toJsonDictionary: [String: Any] {
        let jsonEncoder: JSONEncoder = .default
        guard let data = try? jsonEncoder.encode(self) else { return [:] }
        let dictionary = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
        return dictionary ?? [:]
    }
}