import CasePaths
import Foundation
@preconcurrency import URLRouting

public extension SiteRoute {

  /// Represents api routes that can be interacted with.
  ///
  /// These routes return json information, as opposed to html like the view routes.
  enum Api: Sendable, Equatable {

    case employee(EmployeeRoute)
    case login(User.Login)
    case purchaseOrder(PurchaseOrderRoute)
    case user(UserRoute)
    case vendor(VendorRoute)
    case vendorBranch(VendorBranchRoute)

    static let rootPath = Path { "api"; "v1" }

    public static let router = OneOf {
      Route(.case(Self.employee)) {
        rootPath
        EmployeeRoute.router
      }
      Route(.case(Self.login)) {
        Path { "api"; "v1"; "login" }
        Method.post
        Body(.json(User.Login.self))
      }
      Route(.case(Self.purchaseOrder)) {
        rootPath
        PurchaseOrderRoute.router
      }
      Route(.case(Self.user)) {
        rootPath
        UserRoute.router
      }
      Route(.case(Self.vendor)) {
        rootPath
        VendorRoute.router
      }
      Route(.case(Self.vendorBranch)) {
        rootPath
        VendorBranchRoute.router
      }
    }

    public enum EmployeeRoute: Sendable, Equatable {
      case create(Employee.Create)
      case delete(id: Employee.ID)
      case get(id: Employee.ID)
      case index
      case update(id: Employee.ID, updates: Employee.Update)

      static let rootPath = "employees"

      public static let router = OneOf {
        Route(.case(Self.create)) {
          Path { rootPath }
          Method.post
          Body(.json(Employee.Create.self))
        }
        Route(.case(Self.delete(id:))) {
          Path { rootPath; Employee.ID.parser() }
          Method.delete
        }
        Route(.case(Self.index)) {
          Path { rootPath }
          Method.get
        }
        Route(.case(Self.get(id:))) {
          Path { rootPath; Employee.ID.parser() }
          Method.get
        }
        Route(.case(Self.update(id:updates:))) {
          Path { rootPath; Employee.ID.parser() }
          Method.put
          Body(.json(Employee.Update.self))
        }
      }
    }

    public enum PurchaseOrderRoute: Sendable, Equatable {
      case create(PurchaseOrder.Create)
      case delete(id: PurchaseOrder.ID)
      case get(id: PurchaseOrder.ID)
      case index
      case page(page: Int, limit: Int)

      static let rootPath = "purchase-orders"

      public static let router = OneOf {
        Route(.case(Self.create)) {
          Path { rootPath }
          Method.post
          Body(.json(PurchaseOrder.Create.self))
        }
        Route(.case(Self.delete(id:))) {
          Path { rootPath; PurchaseOrder.ID.parser() }
          Method.delete
        }
        Route(.case(Self.get(id:))) {
          Path { rootPath; Digits() }
          Method.get
        }
        Route(.case(Self.index)) {
          Path { rootPath }
          Method.get
        }
        Route(.case(Self.page(page:limit:))) {
          Path { rootPath; "next" }
          Method.get
          Query {
            Field("page", default: 1) { Digits() }
            Field("limit", default: 25) { Digits() }
          }
        }
      }
    }

    public enum UserRoute: Sendable, Equatable {
      case delete(id: User.ID)
      case create(User.Create)
      case get(id: User.ID)
      case index
      case resetPassword(id: User.ID, request: User.ResetPassword)
      case update(id: User.ID, updates: User.Update)

      static let rootPath = "users"

      public static let router = OneOf {
        Route(.case(Self.create)) {
          Path { rootPath }
          Method.post
          Body(.json(User.Create.self))
        }
        Route(.case(Self.delete(id:))) {
          Path { rootPath; User.ID.parser() }
          Method.delete
        }
        Route(.case(Self.get(id:))) {
          Path { rootPath; User.ID.parser() }
          Method.get
        }
        Route(.case(Self.index)) {
          Path { rootPath }
          Method.get
        }
        Route(.case(Self.resetPassword(id:request:))) {
          Path { rootPath; User.ID.parser(); "reset-password" }
          Method.patch
          Body(.json(User.ResetPassword.self))
        }
        Route(.case(Self.update(id:updates:))) {
          Path { rootPath; User.ID.parser() }
          Method.patch
          Body(.json(User.Update.self))
        }
      }
    }

    public enum VendorRoute: Sendable, Equatable {
      case delete(id: Vendor.ID)
      case index(withBranches: Bool? = nil)
      case create(Vendor.Create)
      case get(id: Vendor.ID)
      case update(id: Vendor.ID, updates: Vendor.Update)

      static let rootPath = "vendors"

      public static let router = OneOf {
        Route(.case(Self.delete(id:))) {
          Path { rootPath; Vendor.ID.parser() }
          Method.delete
        }
        Route(.case(Self.create)) {
          Path { rootPath }
          Method.post
          Body(.json(Vendor.Create.self))
        }
        Route(.case(Self.get(id:))) {
          Path { rootPath; Vendor.ID.parser() }
          Method.get
        }
        Route(.case(Self.index(withBranches:))) {
          Path { rootPath }
          Method.get
          Query {
            Optionally {
              Field("branches", default: nil) {
                Bool.parser()
              }
            }
          }
        }
        Route(.case(Self.update(id:updates:))) {
          Path { rootPath; Vendor.ID.parser() }
          Method.put
          Body(.json(Vendor.Update.self))
        }
      }
    }

    public enum VendorBranchRoute: Sendable, Equatable {
      case delete(id: VendorBranch.ID)
      case create(VendorBranch.Create)
      case get(id: VendorBranch.ID)
      case index(for: Vendor.ID? = nil)
      case update(id: VendorBranch.ID, updates: VendorBranch.Update)

      public static let router = OneOf {
        Route(.case(Self.create)) {
          Path { "vendors"; "branches" }
          Method.post
          Body(.json(VendorBranch.Create.self))
        }
        Route(.case(Self.delete(id:))) {
          Path { "vendors"; "branches"; VendorBranch.ID.parser() }
          Method.delete
        }
        Route(.case(Self.get(id:))) {
          Path { "vendors"; "branches"; VendorBranch.ID.parser() }
          Method.get
        }
        Route(.case(Self.index(for:))) {
          Path { "vendors"; "branches" }
          Method.get
          Query {
            Optionally { Field("vendorID", default: nil) { VendorBranch.ID.parser() } }
          }
        }
        Route(.case(Self.update(id:updates:))) {
          Path { "vendors"; "branches"; VendorBranch.ID.parser() }
          Method.put
          Body(.json(VendorBranch.Update.self))
        }
      }
    }
  }
}