import CoreFoundation
import Models
import Validations

extension ProposedKWInterpolation.Request {

  private static let oversizingLimit = 175

  func respond() async throws -> ProposedKWInterpolation.Response {
    try await validate()
    let (requiredKW, optionalHeatPump) = try await requiredKW()
    let capacityAsPercentOfLoad = normalizePercentage(proposedKW, requiredKW)

    var failures = [String]()
    if capacityAsPercentOfLoad > Self.oversizingLimit {
      failures.append("Oversizing failure.")
    }

    return .init(
      failures: failures.isEmpty ? nil : failures,
      supplementalHeatRequired: requiredKW,
      capacityAsPercentOfLoad: capacityAsPercentOfLoad,
      oversizingLimit: Self.oversizingLimit,
      altitudeAdjustmentMultiplier: optionalHeatPump?.altitudeAdjustmentMultiplier,
      balancePointTemperature: optionalHeatPump?.balancePointTemperature,
      capacityAtDesign: optionalHeatPump?.capacityAtDesign,
      finalCapacity: optionalHeatPump?.finalCapacity
    )
  }

  private var heatPumpRequest: HeatPumpHeatingInterpolation.Request? {
    guard let winterDesignTemperature, let climateType, let capacity else {
      return nil
    }
    return .init(
      winterDesignTemperature: winterDesignTemperature,
      heatLoss: heatLoss,
      climateType: climateType,
      capacity: capacity
    )
  }

  private func requiredKW() async throws -> (Int, HeatPumpHeatingInterpolation.Response?) {
    guard let heatPumpRequest = heatPumpRequest else {
      let requiredKW = try await RequiredKW.Request(heatLoss: heatLoss).respond()
      return (Int(requiredKW.requiredKW), nil)
    }
    let heatPumpResponse = try await heatPumpRequest.respond()
    return (heatPumpResponse.supplementalHeatRequired, heatPumpResponse)
  }

}

extension ProposedKWInterpolation.Request: AsyncValidatable {
  public var body: some AsyncValidation<Self> {
    AsyncValidator.accumulating {
      AsyncValidator.greaterThan(\.heatLoss, 0)
      AsyncValidator.greaterThan(\.proposedKW, 0)
    }
  }
}