import Dependencies
import DependenciesMacros
import SharedModels
import Vapor

public extension DatabaseClient {
  @DependencyClient
  struct VendorBranches: Sendable {
    public var create: @Sendable (VendorBranch.Create) async throws -> VendorBranch
    public var delete: @Sendable (VendorBranch.ID) async throws -> Void
    public var fetchAll: @Sendable (FetchRequest) async throws -> [VendorBranch]
    public var get: @Sendable (VendorBranch.ID) async throws -> VendorBranch?
    public var update: @Sendable (VendorBranch.ID, VendorBranch.Update) async throws -> VendorBranch

    public enum FetchRequest: Equatable {
      case all
      case `for`(vendorID: Vendor.ID)
    }

    public func fetchAll() async throws -> [VendorBranch] {
      try await fetchAll(.all)
    }
  }
}

extension VendorBranch: Content {}
extension VendorBranch.Create: Content {}
extension VendorBranch.Update: Content {}
extension DatabaseClient.VendorBranches.FetchRequest: Content {}

extension DatabaseClient.VendorBranches: TestDependencyKey {
  public static let testValue: DatabaseClient.VendorBranches = Self()
}

#if DEBUG
  typealias VendorBranchMockStorage = MockStorage<
    VendorBranch,
    VendorBranch.Create,
    DatabaseClient.VendorBranches.FetchRequest,
    Void,
    VendorBranch.Update
  >

  private extension VendorBranchMockStorage {

    init(_ mocks: [VendorBranch]) {
      @Dependency(\.date.now) var now
      @Dependency(\.uuid) var uuid

      self.init(
        mocks,
        create: {
          VendorBranch(id: uuid(), name: $0.name, vendorID: $0.vendorID, createdAt: now, updatedAt: now)
        },
        fetch: { request in
          switch request {
          case .all:
            return { _ in true }
          case let .for(vendorID):
            return { $0.vendorID == vendorID }
          }
        },
        update: { branch, updates in
          let model = VendorBranch(
            id: branch.id,
            name: updates.name ?? branch.name,
            vendorID: branch.vendorID,
            createdAt: branch.createdAt,
            updatedAt: now
          )

          branch = model
        }
      )
    }
  }

  public extension DatabaseClient.VendorBranches {
    static func mock(_ mocks: [VendorBranch] = []) -> Self {
      let storage = VendorBranchMockStorage(mocks)
      return .init(
        create: { try await storage.create($0) },
        delete: { try await storage.delete($0) },
        fetchAll: { try await storage.fetchAll($0) },
        get: { try await storage.get($0) },
        update: { try await storage.update($0, $1) }
      )
    }
  }

#endif