import SwiftUI

// 1. Model

struct Todo: Codable, Identifiable {
    let id: Int
    let title: String
    let completed: Bool
}

// 2. Client (fetch todos)

struct TodoClient {
    var fetchTodos: @Sendable () async throws -> [Todo]

    static let live = Self(
        fetchTodos: {
            guard let url = URL(string: "https://jsonplaceholder.typicode.com/todos/") else { throw URLError(.badURL) }
            let (data, _) = try await URLSession.shared.data(from: url)
            let todos = try JSONDecoder().decode([Todo].self, from: data)
            return todos
        }
    )
}

// 3. View (display todos, handle errors)

struct TodoView: View {
    @State var todos: [Todo] = []
    @State var errorMessage: String? = nil
    private let client: TodoClient = .live

    var body: some View {
        List {
            ForEach(todos) { todo in
                HStack {
                    Image(systemName: todo.completed ? "checkmark.circle": "circle")
                        .foregroundStyle(todo.completed ? .green : .gray)
                    Text("\(todo.title)")
                }
            }
        }
        .navigationTitle("Todo List")
        .task { await fetch() }
        .alert("Error", isPresented: .constant(errorMessage != nil)) {
            Button("OK", role: .cancel) { errorMessage = nil }
        } message: {
            Text(errorMessage ?? "No Error")
        }
    }

    func fetch() async {
        do {
            todos = try await client.fetchTodos()
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

#Preview {
    NavigationStack {
        TodoView()
    }
}

import SwiftUI

// 1. Models
// TodoDTO: The raw data from the API
// TodoDMO: A "cleaned-up" version of the data for actual app use

struct TodoDTO: Codable {
    let id: Int
    let title: String
    let completed: Bool

    func toDomainModelObject() -> TodoDMO {
        TodoDMO(id: id, label: title, isCompleted: completed)
    }
}

struct TodoDMO: Identifiable {
    let id: Int
    let label: String
    let isCompleted: Bool
}

// 2. "Data Source"
// Fetches TodoDTOs from an API, making things more complicated than they need to be

protocol TodoDataSource {
    func fetchTodos() async throws -> [TodoDTO]
}

enum TodoDataSourceError: Error {
    case badUrl
    case requestError
    case decodingError
    case statusNotOK
}

struct TodoDataSourceImplementation: TodoDataSource {
    func fetchTodos() async throws -> [TodoDTO] {
        let urlString = "https://jsonplaceholder.typicode.com/todos/"
        guard let url = URL(string: urlString) else {
            throw TodoDataSourceError.badUrl
        }
        guard let (data, response) = try? await URLSession.shared.data(from: url) else {
            throw TodoDataSourceError.requestError
        }
        guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
            throw TodoDataSourceError.statusNotOK
        }
        guard let todos = try? JSONDecoder().decode([TodoDTO].self, from: data) else {
            throw TodoDataSourceError.decodingError
        }
        return todos
    }
}

// 3. "Repository"
// Converts TodoDTOs to TodoDMOs while adding an extra layer for no obvious reason

protocol TodoRepository {
    func fetchTodos() async throws -> [TodoDMO]
}

enum TodoRepositoryError: Error {
    case decodingError
    case networkError
}

struct TodoRepositoryImplementation: TodoRepository {
    private let dataSource: TodoDataSource

    init(dataSource: TodoDataSource) {
        self.dataSource = dataSource
    }

    func fetchTodos() async throws -> [TodoDMO] {
        do {
            let todosDTO = try await dataSource.fetchTodos()
            return todosDTO.map { $0.toDomainModelObject() }
        } catch TodoDataSourceError.decodingError {
            throw TodoRepositoryError.decodingError
        } catch {
            throw TodoRepositoryError.networkError
        }
    }
}

// 4. "UseCase"
// A glorified wrapper to call the repository and handle errors in a slightly different way

protocol TodoGetUseCase {
    func execute() async -> Result<[TodoDMO], TodoGetUseCaseError>
}

enum TodoGetUseCaseError: Error {
    case networkError
    case decodingError
}

struct TodoGetUseCaseImplementation: TodoGetUseCase {
    private let repository: TodoRepository

    init(repository: TodoRepository) {
        self.repository = repository
    }

    func execute() async -> Result<[TodoDMO], TodoGetUseCaseError> {
        do {
            let todos = try await repository.fetchTodos()
            return .success(todos)
        } catch {
            return .failure(error is TodoRepositoryError ? .decodingError : .networkError)
        }
    }
}

// 5. "ViewModel"
// Mediates between the UseCase and the View, because we always need more layers!

@Observable
class TodoListViewModel {
    var todos: [TodoDMO] = []
    var errorMessage = ""
    var hasError = false

    private let useCase: TodoGetUseCase

    init(useCase: TodoGetUseCase) {
        self.useCase = useCase
    }

    func loadTodos() async {
        errorMessage = ""
        hasError = false
        let result = await useCase.execute()
        switch result {
        case .success(let todos):
            self.todos = todos
        case .failure(let error):
            self.todos = []
            errorMessage = error.localizedDescription
            hasError = true
        }
    }
}

// 6. View
// Finally, something useful: displays todos and errors, cleaning up after all the other layers

struct DDDTodoView: View {
    @Bindable var viewModel: TodoListViewModel

    init(viewModel: TodoListViewModel) {
        self.viewModel = viewModel
    }

    var body: some View {
        List {
            ForEach(viewModel.todos) { todo in
                HStack {
                    Image(systemName: todo.isCompleted ? "checkmark.circle" : "circle")
                        .foregroundColor(todo.isCompleted ? .green : .gray)
                    Text(todo.label)
                }
            }
        }
        .navigationTitle("Todo List")
        .task { await viewModel.loadTodos() }
        .alert("Error", isPresented: $viewModel.hasError) {
            Button("OK", role: .cancel) {}
        } message: {
            Text(viewModel.errorMessage)
        }
    }
}

#Preview {
    @Previewable @State var viewModel = TodoListViewModel(
        useCase: TodoGetUseCaseImplementation(
            repository: TodoRepositoryImplementation(
                dataSource: TodoDataSourceImplementation()
            )
        ))
    NavigationView {
        DDDTodoView(viewModel: viewModel)
    }
}