import DatabaseClientLive
import Dependencies
import Fluent
import FluentSQLiteDriver
import NIOSSL
import SharedModels
import Vapor
@preconcurrency import VaporRouting

// configures your application
public func configure(
  _ app: Application,
  makeDatabaseClient: @escaping (any Database) -> DatabaseClient = { .live(database: $0) }
) async throws {
  // cors middleware should come before default error middleware using `at: .beginning`
  let corsConfiguration = CORSMiddleware.Configuration(
    allowedOrigin: .all,
    allowedMethods: [.GET, .POST, .PUT, .OPTIONS, .DELETE, .PATCH],
    allowedHeaders: [.accept, .authorization, .contentType, .origin,
                     .xRequestedWith, .userAgent, .accessControlAllowOrigin]
  )
  let cors = CORSMiddleware(configuration: corsConfiguration)
  app.middleware.use(cors, at: .beginning)

  app.middleware.use(FileMiddleware(publicDirectory: app.directory.publicDirectory))
  app.middleware.use(app.sessions.middleware)

  #if DEBUG
    app.lifecycle.use(BrowserSyncHandler())
  #endif

  switch app.environment {
  case .production, .development:
    let dbFileName = Environment.get("SQLITE_FILENAME") ?? "db.sqlite"
    app.databases.use(DatabaseConfigurationFactory.sqlite(.file(dbFileName)), as: .sqlite)
  default:
    app.databases.use(DatabaseConfigurationFactory.sqlite(.memory), as: .sqlite)
  }

  let databaseClient = makeDatabaseClient(app.db)

  if app.environment != .testing {
    try await app.migrations.add(databaseClient.migrations())
  }

  app.middleware.use(DependenciesMiddleware(database: databaseClient))

  app.mount(
    SiteRoute.router,
    middleware: {
      if app.environment == .testing {
        return nil
      } else {
        return $0.middleware()
      }
    },
    use: siteHandler
  )

  if app.environment != .testing {
    try await app.autoMigrate()
  }

  #if DEBUG
    app.asyncCommands.use(SeedCommand(), as: "seed")
  #endif
  app.asyncCommands.use(GenerateAdminUserCommand(), as: "generate-admin")
}

extension SiteRoute {

  func middleware() -> [any Middleware]? {
    switch self {
    case let .api(route):
      return route.middleware
    case .health:
      return nil
    case let .view(route):
      return route.middleware
    }
  }
}

@Sendable
func siteHandler(
  request: Request,
  route: SiteRoute
) async throws -> any AsyncResponseEncodable {
  switch route {
  case let .api(route):
    return try await route.handle(request: request)
  case .health:
    return HTTPStatus.ok
  case let .view(route):
    return try await route.handle(request: request)
  }
}