import Dependencies
import EstimatedPressureDependency
import SharedModels
import XCTest
import Testing

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(
        airflow: 1200,
        manufacturersIncludedFilterPressureDrop: 0,
        returnPlenumPressure: -0.1,
        postFilterPressure: -0.2, // here to test it makes positive.
        preCoilPressure: 0.4,
        supplyPlenumPressure: 0.1
      )
    )

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


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

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

  }

  @Test(
    "Values are positive only",
    arguments: [
      0.1,
      -0.1
    ]
  )
  func valuesArePositiveOnly(value: Double) {
    let positive = Positive<Double>(value)
    #expect(positive.positiveValue == 0.1)
  }

  @Test(
    "PlenumDimension area calculation",
    arguments: [
      (PlenumDimension.rectangular(width: 24, height: 12), 2),
      (PlenumDimension.round(16), 1.4)
    ]
  )
  func plenumDimensionArea(dimension: PlenumDimension, expectation: Double) {
    let sut = round(dimension.areaInSquareFeet * 100) / 100
    #expect(sut == expectation)
  }

}