//
//  TravelAlbumViewModelTests.swift
//  suixinkanTests
//

import XCTest
@testable import suixinkan

@MainActor
/// 旅拍相册 ViewModel 测试。
final class TravelAlbumEntryViewModelTests: XCTestCase {
    func testLoadAlbumsUpdatesListAndTotal() async {
        let api = TravelAlbumMockAPI()
        api.listResponse = TravelAlbumListResponse(total: 1, list: [TravelAlbum(id: 1, name: "A")])
        let viewModel = TravelAlbumEntryViewModel(currentScenicIdProvider: { 1 })

        await viewModel.loadAlbums(api: api)

        XCTAssertEqual(viewModel.albumTotal, 1)
        XCTAssertEqual(viewModel.albums.first?.name, "A")
    }

    func testPreShootRequiresSinglePrice() async {
        let api = TravelAlbumMockAPI()
        let viewModel = TravelAlbumEntryViewModel(currentScenicIdProvider: { 1 })
        var message = ""
        viewModel.onShowMessage = { message = $0 }

        await viewModel.confirmCreate(mode: .preShoot, freeCount: "", singlePrice: "", packagePrice: "", order: nil, api: api)

        XCTAssertEqual(message, "请输入单张照片价格")
        XCTAssertEqual(api.createRequests.count, 0)
    }

    func testPreOrderRequiresOrder() async {
        let api = TravelAlbumMockAPI()
        let viewModel = TravelAlbumEntryViewModel(currentScenicIdProvider: { 1 })
        var message = ""
        viewModel.onShowMessage = { message = $0 }

        await viewModel.confirmCreate(mode: .preOrder, freeCount: "", singlePrice: "", packagePrice: "", order: nil, api: api)

        XCTAssertEqual(message, "请选择绑定订单")
    }

    func testCreateSuccessRefreshesAlbums() async {
        let api = TravelAlbumMockAPI()
        api.createResponse = TravelAlbumCreateResponse(id: 9)
        api.listResponse = TravelAlbumListResponse(total: 1, list: [TravelAlbum(id: 9)])
        let date = Calendar(identifier: .gregorian).date(from: DateComponents(year: 2026, month: 7, day: 7))!
        let viewModel = TravelAlbumEntryViewModel(currentScenicIdProvider: { 1 }, dateProvider: { date })

        await viewModel.confirmCreate(mode: .preShoot, freeCount: "2", singlePrice: "12.5", packagePrice: "88", order: nil, api: api)

        XCTAssertEqual(api.createRequests.first?.name, "2026-07-07-001")
        XCTAssertEqual(api.createRequests.first?.type, 1)
        XCTAssertEqual(viewModel.albums.first?.id, 9)
        XCTAssertFalse(viewModel.isCreateSheetVisible)
    }

    func testOrderAlreadyBoundReloadsOrders() async {
        let api = TravelAlbumMockAPI()
        api.createError = APIError.serverCode(100001, "订单已关联")
        api.availableOrdersResponse = [TravelAlbumAvailableOrder(projectName: "新订单", orderNumber: "NO1")]
        let viewModel = TravelAlbumEntryViewModel(currentScenicIdProvider: { 1 })
        let order = TravelAlbumAvailableOrder(projectName: "项目", orderNumber: "NO0")

        await viewModel.confirmCreate(mode: .preOrder, freeCount: "", singlePrice: "", packagePrice: "", order: order, api: api)

        XCTAssertEqual(api.availableOrdersCallCount, 1)
        XCTAssertEqual(viewModel.availableOrders.first?.projectName, "新订单")
    }
}

@MainActor
/// 旅拍相册详情 ViewModel 测试。
final class TravelAlbumDetailViewModelTests: XCTestCase {
    func testRefreshLoadsInfoAndMaterials() async {
        let api = TravelAlbumMockAPI()
        api.infoResponse = TravelAlbum(id: 2, name: "详情")
        api.materialListResponses = [
            TravelAlbumListResponse(total: 2, list: []),
            TravelAlbumListResponse(total: 2, list: [TravelAlbumMaterial(id: 1), TravelAlbumMaterial(id: 2)]),
        ]
        let viewModel = TravelAlbumDetailViewModel(albumId: 2)

        await viewModel.refreshAll(api: api)

        XCTAssertEqual(viewModel.album?.name, "详情")
        XCTAssertEqual(viewModel.allPhotoCount, 2)
        XCTAssertEqual(viewModel.materials.count, 2)
    }

    func testTabAndSortTriggerMaterialRequests() async {
        let api = TravelAlbumMockAPI()
        api.materialListResponses = [
            TravelAlbumListResponse(total: 0, list: []),
            TravelAlbumListResponse(total: 0, list: []),
        ]
        let viewModel = TravelAlbumDetailViewModel(albumId: 2)

        await viewModel.selectTab(.purchased, api: api)
        await viewModel.setSortOption(.fileNameDesc, api: api)

        XCTAssertEqual(api.materialRequests.first?.isPurchased, 1)
        XCTAssertEqual(api.materialRequests.last?.orderBy, 4)
    }

    func testOnlyUnpurchasedMaterialCanBeSelected() {
        let viewModel = TravelAlbumDetailViewModel(albumId: 2)
        viewModel.toggleSelectionMode()
        viewModel.toggleMaterialSelection(TravelAlbumMaterial(id: 1, status: 2))
        XCTAssertTrue(viewModel.selectedMaterialIds.isEmpty)

        viewModel.toggleMaterialSelection(TravelAlbumMaterial(id: 1, status: 1))
        XCTAssertEqual(viewModel.selectedMaterialIds, [1])
    }

    func testDeleteAlbumCallsCallback() async {
        let api = TravelAlbumMockAPI()
        let viewModel = TravelAlbumDetailViewModel(albumId: 5)
        var deletedId = 0
        viewModel.onDeletedAlbum = { deletedId = $0 }

        await viewModel.deleteAlbum(api: api)

        XCTAssertEqual(api.deletedAlbumIds, [5])
        XCTAssertEqual(deletedId, 5)
    }
}

/// 有线传输 ViewModel 测试。
@MainActor
final class WiredCameraTransferViewModelTests: XCTestCase {
    func testDefaultDisconnectedStateAndOptions() {
        let viewModel = WiredCameraTransferViewModel(albumId: 1, albumTitle: "相册", headerPhone: "13800138000")

        XCTAssertEqual(viewModel.cameraStatusText, "未连接 USB")
        XCTAssertEqual(viewModel.tabCounts, [0, 0, 0])
        XCTAssertEqual(viewModel.photoFormatOption, .jpg)
        XCTAssertEqual(viewModel.transferModeOption, "边拍边传")
        XCTAssertTrue(viewModel.filteredPhotos().isEmpty)
    }

    func testEnteringPageDoesNotListCameraObjects() async {
        let context = makeOTGTestContext()
        let object = CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: Date())
        let driver = MockCameraDriver(objects: [object])
        let manager = MockWiredCameraConnectionManager(driver: driver)
        let viewModel = makeWiredViewModel(context: context, manager: manager)

        viewModel.start()
        try? await Task.sleep(nanoseconds: 80_000_000)

        XCTAssertEqual(driver.listCallCount, 0)
        XCTAssertTrue(viewModel.filteredPhotos().isEmpty)
    }

    func testHistoryImportRequiresConnectedCatalog() {
        let context = makeOTGTestContext()
        let driver = MockCameraDriver(objects: [])
        let manager = MockWiredCameraConnectionManager(driver: driver, isContentCatalogReady: false)
        let viewModel = makeWiredViewModel(context: context, manager: manager)
        var message = ""
        viewModel.onShowMessage = { message = $0 }

        viewModel.start()
        XCTAssertNil(viewModel.makeCameraImportViewModel())

        XCTAssertEqual(message, "相机照片目录尚未就绪，请稍候再试")
    }

    func testHistoryImportCreatesImportViewModelWhenCatalogReady() {
        let context = makeOTGTestContext()
        let jpeg = CameraObject(id: "JPG|10", filename: "IMG_0001.JPG", fileSize: 10, capturedAt: Date())
        let driver = MockCameraDriver(objects: [jpeg])
        let manager = MockWiredCameraConnectionManager(driver: driver)
        let viewModel = makeWiredViewModel(context: context, manager: manager)

        viewModel.start()

        XCTAssertNotNil(viewModel.makeCameraImportViewModel())
        XCTAssertEqual(driver.listCallCount, 0)
    }

    func testHistoryImportDoesNotDownloadFromTransferPage() async {
        let context = makeOTGTestContext()
        let object = CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: Date())
        let driver = MockCameraDriver(objects: [object])
        let manager = MockWiredCameraConnectionManager(driver: driver)
        let viewModel = makeWiredViewModel(context: context, manager: manager)

        viewModel.start()
        _ = viewModel.makeCameraImportViewModel()
        try? await Task.sleep(nanoseconds: 80_000_000)

        XCTAssertEqual(driver.downloadedObjectIds, [])
        XCTAssertTrue(viewModel.filteredPhotos().isEmpty)
    }

    func testStopSuspendsLiveTransferPolling() {
        let context = makeOTGTestContext()
        let manager = MockWiredCameraConnectionManager(driver: MockCameraDriver(objects: []))
        let viewModel = makeWiredViewModel(context: context, manager: manager)

        viewModel.start()
        viewModel.stop()

        XCTAssertEqual(manager.suspendLiveTransferCallCount, 1)
    }
}

/// 旅拍相册相机历史导入 ViewModel 测试。
@MainActor
final class TravelAlbumCameraImportViewModelTests: XCTestCase {
    func testLoadPhotosListsCameraObjectsAndGroupsByDay() async {
        let context = makeOTGTestContext()
        let calendar = Calendar(identifier: .gregorian)
        let first = calendar.date(from: DateComponents(year: 2026, month: 7, day: 8, hour: 10))!
        let second = calendar.date(from: DateComponents(year: 2026, month: 7, day: 7, hour: 10))!
        let driver = MockCameraDriver(objects: [
            CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: first),
            CameraObject(id: "B|10", filename: "B.JPG", fileSize: 10, capturedAt: second),
        ])
        let viewModel = makeImportViewModel(context: context, driver: driver)

        viewModel.loadPhotos()
        await waitUntil {
            if case .loaded(let sections) = viewModel.state {
                return sections.count == 2
            }
            return false
        }

        XCTAssertEqual(driver.listCallCount, 1)
        if case .loaded(let sections) = viewModel.state {
            XCTAssertEqual(sections.first?.photos.first?.id, "A|10")
        } else {
            XCTFail("Expected loaded state")
        }
    }

    func testAlreadyImportedPhotoCannotBeSelected() async throws {
        let context = makeOTGTestContext()
        let object = CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: Date())
        let localFile = try context.store.uniqueOriginalFileURL(filename: "A.JPG", albumId: 9)
        try Data([1]).write(to: localFile)
        context.store.save([
            TravelAlbumOTGPhotoRecord(
                id: "local-id",
                sourceId: object.id,
                fileName: "A.JPG",
                localPath: localFile.path,
                capturedAt: TravelAlbumOTGPhotoStore.transferTimeText(object.capturedAt),
                fileSizeBytes: 1,
                status: .pending,
                albumId: 9,
                userId: "u1"
            )
        ], albumId: 9)
        let viewModel = makeImportViewModel(context: context, driver: MockCameraDriver(objects: [object]))

        viewModel.loadPhotos()
        await waitUntil {
            if case .loaded = viewModel.state { return true }
            return false
        }
        viewModel.togglePhoto(id: object.id)

        XCTAssertTrue(viewModel.isPhotoAlreadyInAlbum(id: object.id))
        XCTAssertTrue(viewModel.selectedPhotoIds.isEmpty)
    }

    func testSelectionAndSectionToggleStates() async {
        let context = makeOTGTestContext()
        let photos = [
            CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: Date()),
            CameraObject(id: "B|10", filename: "B.JPG", fileSize: 10, capturedAt: Date()),
        ]
        let viewModel = makeImportViewModel(context: context, driver: MockCameraDriver(objects: photos))

        viewModel.loadPhotos()
        await waitUntil {
            if case .loaded = viewModel.state { return true }
            return false
        }
        guard case .loaded(let sections) = viewModel.state, let section = sections.first else {
            return XCTFail("Expected loaded state")
        }

        viewModel.togglePhoto(id: photos[0].id)
        XCTAssertTrue(viewModel.isSectionPartiallySelected(section))
        XCTAssertFalse(viewModel.isSectionFullySelected(section))

        viewModel.toggleSection(section)
        XCTAssertTrue(viewModel.isSectionFullySelected(section))

        viewModel.toggleSection(section)
        XCTAssertTrue(viewModel.selectedPhotoIds.isEmpty)
    }

    func testImportSelectedDownloadsOnlySelectedAndWritesPendingRecords() async {
        let context = makeOTGTestContext()
        let selected = CameraObject(id: "A|10", filename: "A.JPG", fileSize: 10, capturedAt: Date())
        let unselected = CameraObject(id: "B|10", filename: "B.JPG", fileSize: 10, capturedAt: Date())
        let driver = MockCameraDriver(objects: [selected, unselected])
        let viewModel = makeImportViewModel(context: context, driver: driver)

        viewModel.loadPhotos()
        await waitUntil {
            if case .loaded = viewModel.state { return true }
            return false
        }
        viewModel.togglePhoto(id: selected.id)
        viewModel.importSelected()
        await waitUntil {
            if case .finished = viewModel.state { return true }
            return false
        }

        XCTAssertEqual(driver.downloadedObjectIds, [selected.id])
        let records = context.store.load(albumId: 9)
        XCTAssertEqual(records.count, 1)
        XCTAssertEqual(records.first?.sourceId, selected.id)
        XCTAssertEqual(records.first?.status, .pending)
    }

    func testImportSelectedContinuesAfterSingleFailure() async {
        let context = makeOTGTestContext()
        let failed = CameraObject(id: "F|10", filename: "F.JPG", fileSize: 10, capturedAt: Date())
        let success = CameraObject(id: "S|10", filename: "S.JPG", fileSize: 10, capturedAt: Date())
        let driver = MockCameraDriver(objects: [failed, success], failingObjectIds: [failed.id])
        let viewModel = makeImportViewModel(context: context, driver: driver)

        viewModel.loadPhotos()
        await waitUntil {
            if case .loaded(let sections) = viewModel.state {
                sections.first?.photos.count == 2
            } else {
                false
            }
        }
        guard case .loaded(let sections) = viewModel.state, let section = sections.first else {
            return XCTFail("Expected loaded state")
        }
        viewModel.toggleSection(section)
        viewModel.importSelected()
        await waitUntil {
            if case .finished = viewModel.state { return true }
            return false
        }

        XCTAssertEqual(Set(driver.downloadedObjectIds), [failed.id, success.id])
        XCTAssertTrue(viewModel.failedPhotoIds.contains(failed.id))
        XCTAssertEqual(context.store.load(albumId: 9).first?.sourceId, success.id)
    }

    func testSonyEmptyCatalogShowsMTPHelp() async {
        let context = makeOTGTestContext()
        let driver = MockCameraDriver(platform: .sony, objects: [])
        let viewModel = makeImportViewModel(context: context, driver: driver)

        viewModel.loadPhotos()
        await waitUntil {
            if case .failed = viewModel.state { return true }
            return false
        }

        XCTAssertTrue(viewModel.shouldShowSonyMTPHelp)
    }

    private func makeImportViewModel(
        context: OTGTestContext,
        driver: MockCameraDriver
    ) -> TravelAlbumCameraImportViewModel {
        prepareAppStoreForOTGTests()
        return TravelAlbumCameraImportViewModel(
            albumId: 9,
            albumTitle: "相册",
            driver: driver,
            storage: context.store
        )
    }
}

/// OTG 测试存储上下文。
private struct OTGTestContext {
    let root: URL
    let store: TravelAlbumOTGPhotoStore
}

@MainActor
private func makeWiredViewModel(
    context: OTGTestContext,
    manager: MockWiredCameraConnectionManager,
    uploader: MockTravelAlbumOTGUploader? = nil
) -> WiredCameraTransferViewModel {
    prepareAppStoreForOTGTests()
    return WiredCameraTransferViewModel(
        albumId: 9,
        albumTitle: "相册",
        headerPhone: "13800138000",
        connectionManager: manager,
        storage: context.store,
        uploader: uploader ?? MockTravelAlbumOTGUploader()
    )
}

@MainActor
private func makeOTGTestContext() -> OTGTestContext {
    let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
    let store = TravelAlbumOTGPhotoStore(
        context: TravelAlbumOTGStorageContext(
            accountCachePrefix: "u1_photog",
            userId: "u1",
            scenicId: 11,
            storeId: 22
        ),
        applicationSupportDirectory: root.appendingPathComponent("ApplicationSupport", isDirectory: true),
        cachesDirectory: root.appendingPathComponent("Caches", isDirectory: true)
    )
    return OTGTestContext(root: root, store: store)
}

@MainActor
private func prepareAppStoreForOTGTests() {
    AppStore.shared.userId = "u1"
    AppStore.shared.accountType = "photog"
    AppStore.shared.currentScenicId = 11
    AppStore.shared.currentStoreId = 22
}

private func waitUntil(
    timeout: TimeInterval = 1.0,
    condition: @escaping @MainActor () -> Bool
) async {
    let deadline = Date().addingTimeInterval(timeout)
    while Date() < deadline {
        if await condition() { return }
        try? await Task.sleep(nanoseconds: 20_000_000)
    }
}

/// 有线相机连接管理测试替身。
@MainActor
private final class MockWiredCameraConnectionManager: WiredCameraConnectionManaging {
    weak var delegate: ConnectionManagerDelegate?
    var state: ConnectionState
    var currentDriver: CameraDriver?
    var isContentCatalogReady: Bool
    private(set) var suspendLiveTransferCallCount = 0

    init(
        state: ConnectionState = .connected(platform: .canon, deviceName: "Canon"),
        driver: CameraDriver?,
        isContentCatalogReady: Bool = true
    ) {
        self.state = state
        self.currentDriver = driver
        self.isContentCatalogReady = isContentCatalogReady
    }

    func configureLiveTransfer(albumID: Int?) {}
    func start() {}
    func unbindDelegate() {}
    func suspendLiveTransfer() {
        suspendLiveTransferCallCount += 1
    }
    func disconnect() {
        state = .disconnected
    }
}

/// 相机 Driver 测试替身。
private final class MockCameraDriver: CameraDriver {
    let platform: CameraPlatform
    let deviceInfo: CameraDeviceInfo
    private let objects: [CameraObject]
    private let failingObjectIds: Set<String>
    private(set) var listCallCount = 0
    private(set) var downloadedObjectIds: [String] = []

    init(
        platform: CameraPlatform = .canon,
        objects: [CameraObject],
        failingObjectIds: Set<String> = []
    ) {
        self.platform = platform
        self.deviceInfo = CameraDeviceInfo(
            name: "Canon",
            manufacturer: "Canon",
            model: "Mock",
            serialNumber: nil,
            usbVendorID: 0x04A9,
            usbProductID: 1
        )
        self.objects = objects
        self.failingObjectIds = failingObjectIds
    }

    func connect() async throws {}
    func disconnect() {}

    func listObjects() async throws -> [CameraObject] {
        listCallCount += 1
        return objects
    }

    func requestThumbnailData(for object: CameraObject, maxPixelSize: Int) async -> Data? {
        nil
    }

    func downloadObject(_ object: CameraObject, to directory: URL) async throws -> URL {
        downloadedObjectIds.append(object.id)
        if failingObjectIds.contains(object.id) {
            throw CameraError.connectionFailed("下载失败")
        }
        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
        let url = directory.appendingPathComponent(object.filename)
        try Data([1, 2, 3]).write(to: url, options: .atomic)
        return url
    }
}

/// OTG 上传测试替身。
@MainActor
private final class MockTravelAlbumOTGUploader: TravelAlbumOTGUploading {
    private(set) var uploadCallCount = 0

    func upload(
        record: TravelAlbumOTGPhotoRecord,
        scenicId: Int,
        progress: @escaping (Int) -> Void
    ) async throws -> TravelAlbumMaterial {
        uploadCallCount += 1
        return TravelAlbumMaterial(id: 1, fileName: record.fileName, fileUrl: "https://cdn.example.com/\(record.fileName)")
    }
}

/// 旅拍相册 API 测试替身。
@MainActor
final class TravelAlbumMockAPI: TravelAlbumServing {
    struct MaterialRequest: Equatable {
        let userEquityTravelId: Int
        let page: Int
        let pageSize: Int
        let orderBy: Int
        let isPurchased: Int?
    }

    var availableOrdersResponse: [TravelAlbumAvailableOrder] = []
    var listResponse = TravelAlbumListResponse<TravelAlbum>()
    var createResponse = TravelAlbumCreateResponse(id: 0)
    var infoResponse = TravelAlbum()
    var materialListResponses: [TravelAlbumListResponse<TravelAlbumMaterial>] = []
    var uploadMaterialResponse = TravelAlbumMaterial()
    var mpCodeResponse = TravelAlbumMpCodeResponse(mpCodeOssUrl: "")
    var createError: Error?

    private(set) var availableOrdersCallCount = 0
    private(set) var createRequests: [TravelAlbumCreateRequest] = []
    private(set) var materialRequests: [MaterialRequest] = []
    private(set) var uploadMaterialRequests: [TravelAlbumUploadMaterialRequest] = []
    private(set) var deletedAlbumIds: [Int] = []
    private(set) var deletedMaterialIds: [Int] = []

    func availableOrders() async throws -> [TravelAlbumAvailableOrder] {
        availableOrdersCallCount += 1
        return availableOrdersResponse
    }

    func create(_ request: TravelAlbumCreateRequest) async throws -> TravelAlbumCreateResponse {
        createRequests.append(request)
        if let createError { throw createError }
        return createResponse
    }

    func list(page: Int, pageSize: Int) async throws -> TravelAlbumListResponse<TravelAlbum> {
        listResponse
    }

    func info(id: Int) async throws -> TravelAlbum {
        infoResponse
    }

    func materialList(
        userEquityTravelId: Int,
        page: Int,
        pageSize: Int,
        orderBy: Int,
        isPurchased: Int?
    ) async throws -> TravelAlbumListResponse<TravelAlbumMaterial> {
        materialRequests.append(
            MaterialRequest(
                userEquityTravelId: userEquityTravelId,
                page: page,
                pageSize: pageSize,
                orderBy: orderBy,
                isPurchased: isPurchased
            )
        )
        if materialListResponses.isEmpty { return TravelAlbumListResponse() }
        return materialListResponses.removeFirst()
    }

    func uploadMaterial(_ request: TravelAlbumUploadMaterialRequest) async throws -> TravelAlbumMaterial {
        uploadMaterialRequests.append(request)
        return uploadMaterialResponse
    }

    func deleteAlbum(id: Int) async throws {
        deletedAlbumIds.append(id)
    }

    func deleteMaterial(id: Int) async throws {
        deletedMaterialIds.append(id)
    }

    func mpCode(id: Int) async throws -> TravelAlbumMpCodeResponse {
        mpCodeResponse
    }
}