import ApiController
import Dependencies
import DependenciesMacros
import Elementary
import Logging
import PsychrometricClient
import Routes
import Styleguide

public extension DependencyValues {
  var viewController: ViewController {
    get { self[ViewController.self] }
    set { self[ViewController.self] = newValue }
  }
}

public typealias AnySendableHTML = (any HTML & Sendable)

@DependencyClient
public struct ViewController: Sendable {
  public var view: @Sendable (Request) async throws -> AnySendableHTML

  public struct Request: Sendable {
    let route: SiteRoute.View
    let isHtmxRequest: Bool
    let logger: Logger

    public init(
      _ route: SiteRoute.View,
      isHtmxRequest: Bool,
      logger: Logger
    ) {
      self.route = route
      self.isHtmxRequest = isHtmxRequest
      self.logger = logger
    }
  }
}

extension ViewController: TestDependencyKey {
  public static let testValue: ViewController = Self()
}

extension ViewController: DependencyKey {
  public static var liveValue: ViewController {
    @Dependency(\.psychrometricClient) var psychrometricClient

    return .init(view: { request in
      request.logger.debug("View route: \(request.route)")
      switch request.route {
      case .index:
        return MainPage {
          div(.class("space-y-6")) {
            div(.class("pb-8")) {
              p(.class("dark:text-gray-200")) {
                "Professional calculators for HVAC system design and troubleshooting."
              }
            }

            WarningBox(
              "This site is still under construction, not all it's functionality is working.",
              "This page needs updated to display a grid of calculators.",
              "Below are the SVG's used on the site, for making sure they work."
            )
            div {
              p(.class("font-2xl dark:text-gray-200 pb-6")) {
                "SVG's"
              }
              div(.class("grid lg:grid-cols-8 gap-4")) {
                for svg in SVGType.allCases {
                  SVG(svg, color: .blue)
                }
              }
            }
          }
        }

      case let .dehumidifierSize(route):
        switch route {
        case .index:
          return request.respond(DehumidifierSizeForm())
        case let .submit(sizeRequest):
          let response = try await sizeRequest.respond(request.logger)
          return DehumidifierSizeResult(response: response)
        }

      case let .hvacSystemPerformance(route):
        switch route {
        case .index:
          // let response = try await HVACSystemPerformance.Response.mock()
          return request.respond(HVACSystemPerformanceForm(response: nil))
        case let .submit(hvacRequest):
          let response = try await hvacRequest.respond(logger: request.logger)
          return HVACSystemPerformanceResult(response: response)
        }

      case let .moldRisk(route):
        switch route {
        case .index:
          return request.respond(MoldRiskForm(response: nil))
        case let .submit(request):
          let response = try await psychrometricClient.respond(request)
          return MoldRiskResponse(response: response)
        }

      case let .roomPressure(route):
        switch route {
        case let .index(mode):
          return request.respond(RoomPressureForm(mode: mode, response: nil))
        }
      }
    })
  }
}

extension ViewController.Request {

  func respond<C: HTML>(
    _ html: C
  ) -> AnySendableHTML where C: Sendable {
    guard isHtmxRequest else {
      return MainPage { html }
    }
    return html
  }
}