honeyDueKMP/iosApp/iosApp/Task/TaskViewModel.swift

import Foundation
import ComposeApp
import Combine

@MainActor
class TaskViewModel: ObservableObject {
    // MARK: - Published Properties
    @Published var isLoading: Bool = false
    @Published var errorMessage: String?
    @Published var taskCreated: Bool = false
    @Published var taskUpdated: Bool = false
    @Published var taskCancelled: Bool = false
    @Published var taskUncancelled: Bool = false
    @Published var taskMarkedInProgress: Bool = false
    @Published var taskArchived: Bool = false
    @Published var taskUnarchived: Bool = false

    // MARK: - Private Properties
    private let taskApi: TaskApi
    private let tokenStorage: TokenStorage

    // MARK: - Initialization
    init() {
        self.taskApi = TaskApi(client: ApiClient_iosKt.createHttpClient())
        self.tokenStorage = TokenStorage.shared
    }

    // MARK: - Public Methods
    func createTask(request: TaskCreateRequest, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskCreated = false

        taskApi.createTask(token: token, request: request) { result, error in
            if result is ApiResultSuccess<TaskDetail> {
                self.isLoading = false
                self.taskCreated = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func updateTask(id: Int32, request: TaskCreateRequest, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskUpdated = false

        taskApi.updateTask(token: token, id: id, request: request) { result, error in
            if result is ApiResultSuccess<CustomTask> {
                self.isLoading = false
                self.taskUpdated = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func cancelTask(id: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskCancelled = false

        taskApi.cancelTask(token: token, id: id) { result, error in
            if result is ApiResultSuccess<TaskCancelResponse> {
                self.isLoading = false
                self.taskCancelled = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func uncancelTask(id: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskUncancelled = false

        taskApi.uncancelTask(token: token, id: id) { result, error in
            if result is ApiResultSuccess<TaskCancelResponse> {
                self.isLoading = false
                self.taskUncancelled = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func clearError() {
        errorMessage = nil
    }

    func markInProgress(id: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskMarkedInProgress = false

        taskApi.markInProgress(token: token, id: id) { result, error in
            if result is ApiResultSuccess<TaskCancelResponse> {
                self.isLoading = false
                self.taskMarkedInProgress = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func archiveTask(id: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskArchived = false

        taskApi.archiveTask(token: token, id: id) { result, error in
            if result is ApiResultSuccess<TaskCancelResponse> {
                self.isLoading = false
                self.taskArchived = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func unarchiveTask(id: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil
        taskUnarchived = false

        taskApi.unarchiveTask(token: token, id: id) { result, error in
            if result is ApiResultSuccess<TaskCancelResponse> {
                self.isLoading = false
                self.taskUnarchived = true
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func completeTask(taskId: Int32, completion: @escaping (Bool) -> Void) {
        guard let token = tokenStorage.getToken() else {
            errorMessage = "Not authenticated"
            completion(false)
            return
        }

        isLoading = true
        errorMessage = nil

        // Get current date in ISO format
        let dateFormatter = ISO8601DateFormatter()
        let currentDate = dateFormatter.string(from: Date())

        let request = TaskCompletionCreateRequest(
            task: taskId,
            completedByUser: nil,
            completedByName: nil,
            completionDate: currentDate,
            actualCost: nil,
            notes: nil,
            rating: nil
        )

        let completionApi = TaskCompletionApi(client: ApiClient_iosKt.createHttpClient())
        completionApi.createCompletion(token: token, request: request) { result, error in
            if result is ApiResultSuccess<TaskCompletion> {
                self.isLoading = false
                completion(true)
            } else if let errorResult = result as? ApiResultError {
                self.errorMessage = errorResult.message
                self.isLoading = false
                completion(false)
            } else if let error = error {
                self.errorMessage = error.localizedDescription
                self.isLoading = false
                completion(false)
            }
        }
    }

    func resetState() {
        taskCreated = false
        taskUpdated = false
        taskCancelled = false
        taskUncancelled = false
        taskMarkedInProgress = false
        taskArchived = false
        taskUnarchived = false
        errorMessage = nil
    }
}