import Dependencies
import EstimatedPressureDependency
import SharedModels
import XCTest

final class PositiveNumericTests: XCTestCase {

  override func invokeTest() {
    withDependencies {
      $0.estimatedPressuresClient = .liveValue
    } operation: {
      super.invokeTest()
    }
  }

  func testEstimatedAirflow() async throws {
    @Dependency(\.estimatedPressuresClient.estimatedAirflow) var estimatedAirflow

    let sut = try await estimatedAirflow(.init(
      existingAirflow: 1501,
      existingPressure: 0.874,
      targetPressure: 0.5
    ))
    XCTAssertNotNil(sut)
    XCTAssertEqual(round(sut.positiveValue), 1135)
  }

  func testEstimatedPressure() async throws {

    @Dependency(\.estimatedPressuresClient.estimatedPressure) var estimatedPressure

    let sut = try await estimatedPressure(.init(
      existingPressure: 0.3,
      existingAirflow: 1084,
      targetAirflow: 1050
    ))
    XCTAssertEqual(round(sut.positiveValue * 1000) / 1000, 0.281)
  }

  func testExternalStaticPressure() {
    var envelope = EquipmentMeasurement.furnaceAndCoil(
      .init(
        returnPlenumPressure: -0.1,
        postFilterPressure: -0.2, // here to test it makes positive.
        preCoilPressure: 0.4,
        supplyPlenumPressure: 0.1
      )
    )

    var sut = envelope.externalStaticPressure
    XCTAssertEqual(round(sut * 10) / 10, 0.6)


    envelope = .airHandler(
      .init(
        returnPlenumPressure: -0.2,
        postFilterPressure: 0.3,
        postCoilPressure: 0.5,
        supplyPlenumPressure: 0.3)
    )

    sut = envelope.externalStaticPressure
    XCTAssertEqual(round(sut * 10) / 10, 0.7)

  }

  func testExternalStaticPressureReturnsZero() {
    XCTAssertEqual(
      EquipmentMeasurement.airHandler(.init()).externalStaticPressure,
      0
    )
    XCTAssertEqual(
      EquipmentMeasurement.furnaceAndCoil(.init()).externalStaticPressure,
      0
    )
  }

  func testValuesArePositiveOnly() {
    let sut = Positive<Double>(wrappedValue: -0.1)
    XCTAssertEqual(sut.positiveValue, 0.1)

    let sut2 = Positive<Double?>(wrappedValue: -0.1)
    XCTAssertEqual(sut2.positiveValue, 0.1)
  }

  func testReturnPlenumDimensionsAreaCalculation() {
    var sut = PlenumDimension.rectangular(width: 24, height: 12)
    XCTAssertEqual(sut.areaInSquareFeet, 2)

    sut = .round(16)
    XCTAssertEqual(round(sut.areaInSquareFeet * 100) / 100, 1.4)

  }
}