import Elementary
import ElementaryHTMX
import Fluent
import SharedModels

extension HTMLAttribute.hx {
  static func get(route: SharedModels.ViewRoute) -> HTMLAttribute {
    get(SharedModels.ViewRoute.router.path(for: route))
  }

  static func post(route: SharedModels.ViewRoute) -> HTMLAttribute {
    post(SharedModels.ViewRoute.router.path(for: route))
  }

  static func put(route: SharedModels.ViewRoute) -> HTMLAttribute {
    put(SharedModels.ViewRoute.router.path(for: route))
  }

  static func delete(route: SharedModels.ViewRoute) -> HTMLAttribute {
    delete(SharedModels.ViewRoute.router.path(for: route))
  }
}

extension HTMLAttribute.hx {

  static func target(_ target: HXTarget) -> HTMLAttribute {
    Self.target(target.selector)
  }
}

extension HTMLAttribute where Tag: HTMLTrait.Attributes.Global {
  static func id(_ target: HXTarget) -> Self {
    id(target.id)
  }
}

enum HXTarget {
  case body
  case employee(EmployeeKey)
  case float
  case purchaseOrders(PurchaseOrdersKey? = nil)
  case search
  case this
  case user(UserKey)

  var selector: String {
    switch self {
    case .body: return "body"
    case .this: return "this"
    default:
      return "#\(id)"
    }
  }

  var id: String {
    switch self {
    case let .employee(key): return key.key
    case .float: return "float"
    case let .purchaseOrders(key):
      guard let key else { return "purchase-orders" }
      return key.key
    case .search: return "search"
    case let .user(key): return key.key
    case .this, .body:
      fatalError("'\(selector)' can not be used as an id.")
    }
  }

  enum PurchaseOrdersKey {
    case table
    case row(id: PurchaseOrder.ID)

    var key: String {
      switch self {
      case .table: return "purchase-orders-table"
      case let .row(id): return "purchase_order_\(id)"
      }
    }
  }

  enum EmployeeKey {
    case table
    case row(id: Employee.ID)

    var key: String {
      switch self {
      case .table: return "employee-table"
      case let .row(id): return "employee_\(id.uuidString)"
      }
    }
  }

  enum UserKey {
    case form
    case row(id: User.ID)
    case table(Table? = nil)

    var key: String {
      switch self {
      case .form: return "user-form"
      case let .row(id): return "user_\(id)"
      case let .table(table):
        let key = "user-table"
        guard let table else { return key }
        return "\(key)-\(table.rawValue)"
      }
    }

    enum Table: String {
      case body
    }
  }
}

// TODO: Move to MainPage
enum ViewRoute: String {

  case employees
  case login
  case purchaseOrders
  case users
  case vendors

  var title: String {
    switch self {
    case .purchaseOrders:
      return "Purchase Orders"
    default:
      return rawValue.capitalized
    }
  }

  var description: String {
    switch self {
    case .employees:
      return "Employees are who purchase orders can be issued to."
    case .purchaseOrders, .login:
      return ""
    case .users:
      return "Users are who can login and issue purchase orders for employees."
    case .vendors:
      return "Vendors are where purchase orders can be issued to."
    }
  }

}