// View Protocol
protocol LoginViewProtocol: AnyObject {
    func showLoading()
    func hideLoading()
    func showWelcomeMessage(for username: String)
    func showError(_ message: String)
}

// Presenter Protocol
protocol LoginPresenterProtocol: AnyObject {
    var view: LoginViewProtocol? { get set }
    var interactor: LoginInteractorProtocol? { get set }
    var router: LoginRouterProtocol? { get set }

    func viewDidLoad()
    func loginButtonTapped(username: String, password: String)
}

// Interactor Protocol
protocol LoginInteractorProtocol: AnyObject {
    var presenter: LoginInteractorOutputProtocol? { get set }
    func validateAndLogin(username: String, password: String)
}

// Interactor Output Protocol
protocol LoginInteractorOutputProtocol: AnyObject {
    func loginSucceeded(user: User)
    func loginFailed(error: LoginError)
}

// Router Protocol
protocol LoginRouterProtocol: AnyObject {
    static func createModule() -> UIViewController
    func navigateToHome(from view: LoginViewProtocol)
}

class LoginPresenter: LoginPresenterProtocol {
    weak var view: LoginViewProtocol?
    var interactor: LoginInteractorProtocol?
    var router: LoginRouterProtocol?

    func viewDidLoad() {
        // Initial setup if needed
    }

    func loginButtonTapped(username: String, password: String) {
        // Validate input
        guard !username.isEmpty, !password.isEmpty else {
            view?.showError("Please enter both username and password")
            return
        }

        view?.showLoading()
        interactor?.validateAndLogin(username: username, password: password)
    }
}

extension LoginPresenter: LoginInteractorOutputProtocol {
    func loginSucceeded(user: User) {
        view?.hideLoading()
        view?.showWelcomeMessage(for: user.name)

        // Navigate after a short delay
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
            guard let self = self, let view = self.view else { return }
            self.router?.navigateToHome(from: view)
        }
    }

    func loginFailed(error: LoginError) {
        view?.hideLoading()

        let message: String
        switch error {
        case .invalidCredentials:
            message = "Invalid username or password"
        case .networkError:
            message = "Network connection failed. Please try again."
        case .serverError:
            message = "Server error. Please try again later."
        }

        view?.showError(message)
    }
}

enum LoginError: Error {
    case invalidCredentials
    case networkError
    case serverError
}

class LoginInteractor: LoginInteractorProtocol {
    weak var presenter: LoginInteractorOutputProtocol?
    var authService: AuthServiceProtocol

    init(authService: AuthServiceProtocol = AuthService()) {
        self.authService = authService
    }

    func validateAndLogin(username: String, password: String) {
        // Business logic validation
        guard username.count >= 3 else {
            presenter?.loginFailed(error: .invalidCredentials)
            return
        }

        guard password.count >= 6 else {
            presenter?.loginFailed(error: .invalidCredentials)
            return
        }

        // Call API service
        authService.login(username: username, password: password) { [weak self] result in
            DispatchQueue.main.async {
                switch result {
                case .success(let user):
                    self?.presenter?.loginSucceeded(user: user)
                case .failure(let error):
                    self?.handleLoginError(error)
                }
            }
        }
    }

    private func handleLoginError(_ error: Error) {
        // Map network errors to domain errors
        if let urlError = error as? URLError {
            presenter?.loginFailed(error: .networkError)
        } else {
            presenter?.loginFailed(error: .serverError)
        }
    }
}

class LoginRouter: LoginRouterProtocol {
    static func createModule() -> UIViewController {
        let view = LoginViewController()
        let presenter = LoginPresenter()
        let interactor = LoginInteractor()
        let router = LoginRouter()

        // Wire up dependencies
        view.presenter = presenter
        presenter.view = view
        presenter.interactor = interactor
        presenter.router = router
        interactor.presenter = presenter

        return view
    }

    func navigateToHome(from view: LoginViewProtocol) {
        guard let viewController = view as? UIViewController else { return }

        let homeVC = HomeRouter.createModule()
        homeVC.modalPresentationStyle = .fullScreen
        viewController.present(homeVC, animated: true)
    }
}

import ComposableArchitecture

struct LoginState: Equatable {
    var username: String = ""
    var password: String = ""
    var isLoading: Bool = false
    var errorMessage: String?
    var isLoggedIn: Bool = false

    // Computed property for validation
    var isValid: Bool {
        username.count >= 3 && password.count >= 6
    }
}

enum LoginAction: Equatable {
    // User actions
    case usernameChanged(String)
    case passwordChanged(String)
    case loginButtonTapped
    case dismissErrorTapped

    // System actions
    case loginResponse(Result<User, LoginError>)
    case navigateToHome
}

// Domain-specific errors
enum LoginError: Error, Equatable {
    case invalidCredentials
    case networkError
    case serverError

    var message: String {
        switch self {
        case .invalidCredentials:
            return "Invalid username or password"
        case .networkError:
            return "Network connection failed. Please try again."
        case .serverError:
            return "Server error. Please try again later."
        }
    }
}

struct LoginEnvironment {
    var authClient: AuthClient
    var mainQueue: AnySchedulerOf<DispatchQueue>

    // For testing, we can provide mock dependencies
    static let mock = Self(
        authClient: .mock,
        mainQueue: .immediate
    )
}

// Protocol for auth operations
protocol AuthClientProtocol {
    func login(username: String, password: String) -> Effect<User, LoginError>
}

struct AuthClient: AuthClientProtocol {
    var login: (String, String) -> Effect<User, LoginError>

    // Live implementation
    static let live = Self(
        login: { username, password in
            URLSession.shared.dataTaskPublisher(for: loginURL(username, password))
                .map(\.data)
                .decode(type: User.self, decoder: JSONDecoder())
                .mapError { error in
                    if let urlError = error as? URLError {
                        return .networkError
                    }
                    return .serverError
                }
                .eraseToEffect()
        }
    )

    // Mock for testing
    static let mock = Self(
        login: { username, password in
            username == "test" && password == "password"
                ? Effect(value: User(id: "1", name: "Test User"))
                : Effect(error: .invalidCredentials)
        }
    )
}

let loginReducer = Reducer<LoginState, LoginAction, LoginEnvironment> { state, action, environment in
    switch action {

    case .usernameChanged(let username):
        state.username = username
        state.errorMessage = nil
        return .none

    case .passwordChanged(let password):
        state.password = password
        state.errorMessage = nil
        return .none

    case .loginButtonTapped:
        // Validate before making API call
        guard state.isValid else {
            state.errorMessage = "Username must be at least 3 characters and password at least 6"
            return .none
        }

        state.isLoading = true
        state.errorMessage = nil

        // Return an effect that will perform the login
        return environment.authClient
            .login(username: state.username, password: state.password)
            .receive(on: environment.mainQueue)
            .catchToEffect(LoginAction.loginResponse)

    case .loginResponse(.success(let user)):
        state.isLoading = false
        state.isLoggedIn = true

        // Trigger navigation after successful login
        return Effect(value: .navigateToHome)
            .delay(for: 1.0, scheduler: environment.mainQueue)
            .eraseToEffect()

    case .loginResponse(.failure(let error)):
        state.isLoading = false
        state.errorMessage = error.message
        return .none

    case .dismissErrorTapped:
        state.errorMessage = nil
        return .none

    case .navigateToHome:
        // Handle navigation (typically done in the parent reducer or view)
        return .none
    }
}

import SwiftUI
import ComposableArchitecture

struct LoginView: View {
    let store: Store<LoginState, LoginAction>

    var body: some View {
        WithViewStore(self.store) { viewStore in
            VStack(spacing: 20) {
                TextField("Username", text: viewStore.binding(
                    get: \.username,
                    send: LoginAction.usernameChanged
                ))
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .autocapitalization(.none)

                SecureField("Password", text: viewStore.binding(
                    get: \.password,
                    send: LoginAction.passwordChanged
                ))
                .textFieldStyle(RoundedBorderTextFieldStyle())

                if let errorMessage = viewStore.errorMessage {
                    HStack {
                        Text(errorMessage)
                            .foregroundColor(.red)
                            .font(.caption)
                        Spacer()
                        Button(action: { viewStore.send(.dismissErrorTapped) }) {
                            Image(systemName: "xmark.circle.fill")
                        }
                    }
                }

                Button(action: { viewStore.send(.loginButtonTapped) }) {
                    if viewStore.isLoading {
                        ProgressView()
                            .progressViewStyle(CircularProgressViewStyle(tint: .white))
                    } else {
                        Text("Login")
                            .fontWeight(.bold)
                    }
                }
                .frame(maxWidth: .infinity)
                .padding()
                .background(viewStore.isValid ? Color.blue : Color.gray)
                .foregroundColor(.white)
                .cornerRadius(10)
                .disabled(!viewStore.isValid || viewStore.isLoading)
            }
            .padding()
        }
    }
}

// Preview with test data
struct LoginView_Previews: PreviewProvider {
    static var previews: some View {
        LoginView(
            store: Store(
                initialState: LoginState(),
                reducer: loginReducer,
                environment: .mock
            )
        )
    }
}

// Parent feature that contains login
struct AppState: Equatable {
    var login: LoginState
    var home: HomeState?
    var settings: SettingsState
}

enum AppAction {
    case login(LoginAction)
    case home(HomeAction)
    case settings(SettingsAction)
}

let appReducer = Reducer<AppState, AppAction, AppEnvironment>.combine(
    // Child reducers handle their own actions
    loginReducer.pullback(
        state: \.login,
        action: /AppAction.login,
        environment: { $0.login }
    ),
    homeReducer.optional().pullback(
        state: \.home,
        action: /AppAction.home,
        environment: { $0.home }
    ),

    // Parent reducer handles coordination
    Reducer { state, action, environment in
        switch action {
        case .login(.loginResponse(.success)):
            // When login succeeds, initialize home state
            state.home = HomeState()
            return .none

        default:
            return .none
        }
    }
)

import XCTest
import ComposableArchitecture

class LoginTests: XCTestCase {
    func testSuccessfulLogin() {
        let store = TestStore(
            initialState: LoginState(),
            reducer: loginReducer,
            environment: .mock
        )

        // Test the complete flow
        store.send(.usernameChanged("test")) {
            $0.username = "test"
        }

        store.send(.passwordChanged("password")) {
            $0.password = "password"
            $0.isValid = true
        }

        store.send(.loginButtonTapped) {
            $0.isLoading = true
        }

        // Simulate async response
        store.receive(.loginResponse(.success(User(id: "1", name: "Test User")))) {
            $0.isLoading = false
            $0.isLoggedIn = true
        }

        // Verify navigation effect
        store.receive(.navigateToHome)
    }

    func testInvalidCredentials() {
        let store = TestStore(
            initialState: LoginState(username: "short", password: "short"),
            reducer: loginReducer,
            environment: .mock
        )

        store.send(.loginButtonTapped) {
            $0.errorMessage = "Username must be at least 3 characters and password at least 6"
        }
    }
}

// Before: Massive View Controller (MVC)
class ProductListViewController: UIViewController {
    var products: [Product] = []
    let apiService = APIService()

    override func viewDidLoad() {
        super.viewDidLoad()
        loadProducts()
    }

    func loadProducts() {
        apiService.fetchProducts { [weak self] result in
            switch result {
            case .success(let products):
                self?.products = products
                self?.tableView.reloadData()
            case .failure(let error):
                self?.showError(error)
            }
        }
    }
}

// After: VIPER Architecture
// ViewController - Only UI logic
class ProductListViewController: UIViewController {
    var presenter: ProductListPresenterProtocol!

    override func viewDidLoad() {
        super.viewDidLoad()
        presenter.viewDidLoad()
    }
}

extension ProductListViewController: ProductListViewProtocol {
    func showProducts(_ products: [ProductViewModel]) {
        self.products = products
        tableView.reloadData()
    }

    func showError(_ message: String) {
        // Show error UI
    }
}

// Presenter - Coordination logic
class ProductListPresenter: ProductListPresenterProtocol {
    weak var view: ProductListViewProtocol?
    var interactor: ProductListInteractorProtocol?

    func viewDidLoad() {
        interactor?.fetchProducts()
    }
}

// Interactor - Business logic
class ProductListInteractor: ProductListInteractorProtocol {
    weak var presenter: ProductListInteractorOutputProtocol?
    var apiService: APIServiceProtocol

    func fetchProducts() {
        apiService.fetchProducts { [weak self] result in
            switch result {
            case .success(let products):
                self?.presenter?.productsFetched(products)
            case .failure(let error):
                self?.presenter?.productsFetchFailed(error)
            }
        }
    }
}

// UIKit VIPER screen launching SwiftUI TCA screen
class ProfileRouter: ProfileRouterProtocol {
    func navigateToSettings(from view: ProfileViewProtocol) {
        guard let viewController = view as? UIViewController else { return }

        // Create TCA-based SwiftUI view
        let settingsStore = Store(
            initialState: SettingsState(),
            reducer: settingsReducer,
            environment: SettingsEnvironment.live
        )

        let settingsView = SettingsView(store: settingsStore)
        let hostingController = UIHostingController(rootView: settingsView)

        viewController.navigationController?.pushViewController(hostingController, animated: true)
    }
}

// SwiftUI TCA screen navigating back to VIPER
struct SettingsView: View {
    let store: Store<SettingsState, SettingsAction>

    var body: some View {
        WithViewStore(store) { viewStore in
            Form {
                Button("Open Profile (VIPER)") {
                    // Call UIKit navigation through a delegate or coordinator
                    viewStore.send(.navigateToProfile)
                }
            }
        }
    }
}

// In the reducer, handle navigation via effects
case .navigateToProfile:
    // Use environment dependency to trigger UIKit navigation
    return environment.navigation.showProfile()
        .fireAndForget()

// VIPER: Layer-by-layer unit testing with mocks
import XCTest
@testable import YourApp

class LoginPresenterTests: XCTestCase {
    var presenter: LoginPresenter!
    var mockView: MockLoginView!
    var mockInteractor: MockLoginInteractor!
    var mockRouter: MockLoginRouter!

    override func setUp() {
        presenter = LoginPresenter()
        mockView = MockLoginView()
        mockInteractor = MockLoginInteractor()
        mockRouter = MockLoginRouter()

        presenter.view = mockView
        presenter.interactor = mockInteractor
        presenter.router = mockRouter
    }

    func testLoginButtonTapped_WithValidCredentials_CallsInteractor() {
        // Given
        let username = "testuser"
        let password = "password123"

        // When
        presenter.loginButtonTapped(username: username, password: password)

        // Then
        XCTAssertTrue(mockInteractor.validateCredentialsCalled)
        XCTAssertEqual(mockInteractor.capturedUsername, username)
        XCTAssertEqual(mockInteractor.capturedPassword, password)
    }

    func testLoginSucceeded_UpdatesViewAndNavigates() {
        // Given
        let user = User(id: "1", name: "Test User")

        // When
        presenter.loginSucceeded(user: user)

        // Then
        XCTAssertTrue(mockView.showWelcomeMessageCalled)
        XCTAssertEqual(mockView.capturedUsername, "Test User")

        // Verify navigation happens after delay
        let expectation = expectation(description: "Navigation")
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            XCTAssertTrue(self.mockRouter.navigateToHomeCalled)
            expectation.fulfill()
        }
        wait(for: [expectation], timeout: 2.0)
    }
}

// Mock objects
class MockLoginView: LoginViewProtocol {
    var showWelcomeMessageCalled = false
    var capturedUsername: String?

    func showWelcomeMessage(for username: String) {
        showWelcomeMessageCalled = true
        capturedUsername = username
    }
}

// TCA: Comprehensive state-based testing with TestStore
import XCTest
import ComposableArchitecture
@testable import YourApp

class LoginReducerTests: XCTestCase {
    func testLoginFlow_Success() {
        let store = TestStore(
            initialState: LoginState(),
            reducer: loginReducer,
            environment: LoginEnvironment(
                authClient: .mock(result: .success(User(id: "1", name: "Test"))),
                mainQueue: .immediate
            )
        )

        // Type username
        store.send(.usernameChanged("testuser")) {
            $0.username = "testuser"
        }

        // Type password
        store.send(.passwordChanged("password123")) {
            $0.password = "password123"
        }

        // Tap login
        store.send(.loginButtonTapped) {
            $0.isLoading = true
        }

        // Receive success response
        store.receive(.loginResponse(.success(User(id: "1", name: "Test")))) {
            $0.isLoading = false
            $0.isLoggedIn = true
        }

        // Verify navigation effect
        store.receive(.navigateToHome)
    }

    func testLoginFlow_NetworkError() {
        let store = TestStore(
            initialState: LoginState(username: "testuser", password: "password123"),
            reducer: loginReducer,
            environment: LoginEnvironment(
                authClient: .mock(result: .failure(.networkError)),
                mainQueue: .immediate
            )
        )

        store.send(.loginButtonTapped) {
            $0.isLoading = true
        }

        store.receive(.loginResponse(.failure(.networkError))) {
            $0.isLoading = false
            $0.errorMessage = "Network connection failed. Please try again."
        }
    }

    func testDismissError() {
        let store = TestStore(
            initialState: LoginState(errorMessage: "Some error"),
            reducer: loginReducer,
            environment: .mock
        )

        store.send(.dismissErrorTapped) {
            $0.errorMessage = nil
        }
    }
}