import ComposableArchitecture
import SharedModels
import Testing
import XCTest
@testable import PressureEstimationsFeature

struct FlaggedMeasurementListStateTests {

  @Test(
    "Ensure Estimation Has Changes",
    .tags(.flaggedMeasurementList)
  )
  func ensureHasChanges() {
    let reducer = FlaggedMeasurementsList()
    let result = reducer.ensureHasChanges(
      formState: .init(
        existingMeasurement: SharedReader(Shared(.mock(type: .airHandler))),
        cfmTextField: 350,
        filterPressureDrop: 0.1
      ),
      flaggedEstimations: []
    )
    #expect(result != nil)
  }
  
   @Test(
    "Pressure Estimation",
    .tags(.flaggedMeasurementList),
    arguments: [
      (EquipmentMeasurement.EquipmentType.airHandler, Optional<Double>.none),
      (.furnaceAndCoil, nil),
      (.airHandler, 0.1),
      (.furnaceAndCoil, 0.1),
    ]
  )
  func pressureEstimation(
    equipmentType: EquipmentMeasurement.EquipmentType,
    filterPressureDrop: Double?
  ) async throws {
    try await withDependencies {
      $0.estimatedPressuresClient = .liveValue
    } operation: {
      @Dependency(\.estimatedPressuresClient) var client
      let equipmentMeasurement = EquipmentMeasurement.mock(type: equipmentType)
      
      let measurement = try await client.estimatedPressure(
        equipmentMeasurement: equipmentMeasurement,
        airflow: 1050,
        filterPressureDrop: filterPressureDrop
      )
      
      print(measurement)
      #expect(measurement.equipmentType == equipmentType)
      #expect(measurement.manufacturersIncludedFilterPressureDrop == equipmentMeasurement.manufacturersIncludedFilterPressureDrop)
    }
  }
  
  @Test(
    "Handle Estimation Form",
    .tags(.flaggedMeasurementList),
    arguments: [nil, 0.1]
  )
  func handleEstimationForm(filterPressureDrop: Double?) async throws {
    try await withDependencies {
      $0.estimatedPressuresClient = .liveValue
      $0.uuid = .incrementing
    } operation: {
      @Dependency(\.estimatedPressuresClient) var client
      
      let equipmentMeasurement = EquipmentMeasurement.mock(type: .airHandler)
      let budgets = BudgetedPercentEnvelope(equipmentType: .airHandler, fanType: .constantSpeed)
      let flaggedMeasurement = EquipmentMeasurement.FlaggedMeasurement(
        budgets: budgets,
        measurement: equipmentMeasurement,
        ratedPressures: .init(),
        tons: .three
      )
      
      let reducer = FlaggedMeasurementsList()
      let result = try await reducer._handleEstimationForm(
        form: .init(
          existingMeasurement: SharedReader(Shared(equipmentMeasurement)),
          cfmTextField: 350,
          filterPressureDrop: filterPressureDrop,
          name: "Test"
        ),
        state: .init(sharedSettings: Shared(.init(
          budgets: budgets,
          equipmentMeasurement: equipmentMeasurement,
          flaggedEquipmentMeasurement: flaggedMeasurement
        )))
      )
      
      let measurement = try await client.estimatedPressure(
        equipmentMeasurement: equipmentMeasurement,
        airflow: 1050,
        filterPressureDrop: filterPressureDrop
      )
      
      #expect(result != nil)
      #expect(result?.estimationState == .init(
        cfm: .cfmPerTon(350, .three),
        filterPressureDrop: filterPressureDrop,
        name: "Test"
      ))
      
      #expect(result?.flaggedMeasurement == .init(
          budgets: .init(equipmentType: .airHandler, fanType: .constantSpeed),
          measurement: measurement,
          ratedPressures: .init(),
          tons: .three)
      )
    }
  }

}

final class FlaggedMeasurementListReducerTests: XCTestCase {
  
  override func invokeTest() {
    withDependencies {
      $0.uuid = .incrementing
      $0.estimatedPressuresClient = .liveValue
    } operation: {
      super.invokeTest()
    }
  }
  
  @MainActor
  func testFlaggedMeasurementListReducer() async throws {
    @Dependency(\.estimatedPressuresClient) var estimatedPressuresClient
    
    let store = TestStore(
      initialState: FlaggedMeasurementsList.State(
        sharedSettings: Shared(SharedPressureEstimationState(
          budgets: nil,
          equipmentMeasurement: .mock(type: .airHandler),
          equipmentMetadata: .init(
            coolingCapacity: .three,
            fanType: .constantSpeed,
            ratedStaticPressures: .init()
          )
        ))
      )
    ) {
      FlaggedMeasurementsList()
    }
    
    let budgets = BudgetedPercentEnvelope(
      equipmentType: .airHandler,
      fanType: .constantSpeed
    )
    
    let flaggedMeasurement = EquipmentMeasurement.FlaggedMeasurement.init(
      budgets: budgets,
      measurement: .mock(type: .airHandler),
      ratedPressures: .init(),
      tons: .three
    )
    
    await store.send(.view(.onAppear)) {
      $0.sharedSettings.budgets = budgets
      $0.sharedSettings.flaggedEquipmentMeasurement = flaggedMeasurement
    }
    
    await store.send(.view(.addButtonTapped)) {
      $0.destination = .estimationForm(.init(
        existingMeasurement: $0.$sharedSettings.equipmentMeasurement,
        coolingCapacity: $0.sharedSettings.equipmentMetadata.coolingCapacity
      ))
    }
    
    store.exhaustivity = .off
   
    await store.send(.destination(.presented(.estimationForm(.binding(.set(\.cfmTextField, 350))))))
    await store.send(.destination(.presented(.estimationForm(.binding(.set(\.name, "Test"))))))
    await store.send(.destination(.presented(.estimationForm(.binding(.set(\.filterPressureDrop, 0.1))))))
    
    let pressureResult = try await estimatedPressuresClient.estimatedPressure(
      equipmentMeasurement: .mock(type: .airHandler),
      airflow: 1050,
      filterPressureDrop: 0.1
    )
    let flaggedResult = EquipmentMeasurement.FlaggedMeasurement(
      budgets: budgets,
      measurement: pressureResult,
      ratedPressures: .init(),
      tons: .three
    )
    
    store.exhaustivity = .on

    await store.send(.view(.destination(.doneButtonTapped))) {
      $0.destination = nil
    }
    await store.receive(\.receive.success.estimatedFlaggedMeasurement, timeout: 10) {
      $0.sharedSettings.flaggedEstimations[id: UUID(0)] = .init(
        id: UUID(0),
        estimationState: .init(
          cfm: .cfmPerTon(350, .three),
          filterPressureDrop: 0.1,
          name: "Test"
        ),
        flaggedMeasurement: flaggedResult
      )
    }
    
    await store.finish()
    
  }
  
//    @MainActor
//    func testBindingsSetSharedState() async {
//      let store = TestStore(
//        initialState: FlaggedMeasurementsList.State(
//          sharedSettings: Shared(SharedPressureEstimationState(
//            budgets: nil,
//            equipmentMeasurement: .mock(type: .airHandler),
//            equipmentMetadata: .init(
//              coolingCapacity: .three,
//              fanType: .constantSpeed,
//              ratedStaticPressures: .init()
//            )
//          ))
//        )
//      ) {
//        FlaggedMeasurementsList()
//      }
//      
//      await store.send(.binding(.set(\.maxStaticPressure, nil))) {
//        $0.maxStaticPressure = nil
//        $0.sharedSettings.ratedStaticPressures.maximum = 0
//      }
//      await store.send(.binding(.set(\.minStaticPressure, nil))) {
//        $0.minStaticPressure = nil
//        $0.sharedSettings.ratedStaticPressures.minimum = 0
//      }
//      await store.send(.binding(.set(\.ratedStaticPressure, nil))) {
//        $0.ratedStaticPressure = nil
//        $0.sharedSettings.ratedStaticPressures.rated = 0
//      }
//  
//    }
  
}

extension Tag {
  @Tag static var flaggedMeasurementList: Self
}