import Foundation
import ComposableArchitecture

@Reducer
struct IDLoginFeature {
    @ObservableState
    struct State: Equatable {
        var userID: String = ""
        var password: String = ""
        var isPasswordVisible = false
        var isLoading = false
        var errorMessage: String?
        
        // 新增：Account Model 和 Ticket 相关状态
        var accountModel: AccountModel?
        var isTicketLoading = false
        var ticketError: String?
        var loginStep: LoginStep = .initial
        
        enum LoginStep: Equatable {
            case initial        // 初始状态
            case authenticating // 正在进行 OAuth 认证
            case gettingTicket  // 正在获取 Ticket
            case completed      // 认证完成
            case failed         // 认证失败
        }
        
        #if DEBUG
        init() {
            // 移除测试用的硬编码凭据
            self.userID = ""
            self.password = ""
        }
        #endif
    }
    
    enum Action: Equatable {
        case togglePasswordVisibility
        case loginButtonTapped(userID: String, password: String)
        case forgotPasswordTapped
        case backButtonTapped
        case loginResponse(TaskResult<IDLoginResponse>)
        
        // 新增：Ticket 相关 actions
        case requestTicket(accessToken: String)
        case ticketResponse(TaskResult<TicketResponse>)
        case clearTicketError
        case resetLogin
    }
    
    @Dependency(\.apiService) var apiService
    
    var body: some ReducerOf<Self> {
        Reduce { state, action in
            switch action {
            case .togglePasswordVisibility:
                state.isPasswordVisible.toggle()
                return .none
                
            case let .loginButtonTapped(userID, password):
                state.userID = userID
                state.password = password
                state.isLoading = true
                state.errorMessage = nil
                state.ticketError = nil
                state.loginStep = .authenticating
                
                // 实现真实的ID登录API调用
                return .run { send in
                    do {
                        // 使用LoginHelper创建加密的登录请求
                        guard let loginRequest = LoginHelper.createIDLoginRequest(userID: userID, password: password) else {
                            await send(.loginResponse(.failure(APIError.decodingError("加密失败"))))
                            return
                        }
                        
                        // 发起登录请求
                        let response = try await apiService.request(loginRequest)
                        await send(.loginResponse(.success(response)))
                    } catch {
                        if let apiError = error as? APIError {
                            await send(.loginResponse(.failure(apiError)))
                        } else {
                            await send(.loginResponse(.failure(APIError.unknown(error.localizedDescription))))
                        }
                    }
                }
                
            case .forgotPasswordTapped:
                // TODO: 处理忘记密码
                return .none
                
            case .backButtonTapped:
                // 由父级处理返回逻辑
                return .none
                
            case let .loginResponse(.success(response)):
                state.isLoading = false
                if response.isSuccess {
                    // OAuth 认证成功，清除错误信息
                    state.errorMessage = nil
                    
                    // 从响应数据创建 AccountModel
                    if let loginData = response.data,
                       let accountModel = AccountModel.from(loginData: loginData) {
                        state.accountModel = accountModel
                        
                        // 保存用户信息（如果有）
                        if let userInfo = loginData.userInfo {
                            UserInfoManager.saveUserInfo(userInfo)
                        }
                        
                                        debugInfo("✅ ID 登录 OAuth 认证成功")
                debugInfo("🔑 Access Token: \(accountModel.accessToken ?? "nil")")
                debugInfo("🆔 用户 UID: \(accountModel.uid ?? "nil")")
                        
                        // 自动获取 ticket
                        return .send(.requestTicket(accessToken: accountModel.accessToken!))
                    } else {
                        state.errorMessage = "登录数据格式错误"
                        state.loginStep = .failed
                    }
                } else {
                    state.errorMessage = response.errorMessage
                    state.loginStep = .failed
                }
                return .none
                
            case let .loginResponse(.failure(error)):
                state.isLoading = false
                state.errorMessage = error.localizedDescription
                state.loginStep = .failed
                return .none
                
            case let .requestTicket(accessToken):
                state.isTicketLoading = true
                state.ticketError = nil
                state.loginStep = .gettingTicket
                
                return .run { [accountModel = state.accountModel] send in
                    do {
                        // 从 AccountModel 获取 uid，转换为 Int 类型
                        let uid = accountModel?.uid != nil ? Int(accountModel!.uid!) : nil
                        let ticketRequest = TicketHelper.createTicketRequest(accessToken: accessToken, uid: uid)
                        let response = try await apiService.request(ticketRequest)
                        await send(.ticketResponse(.success(response)))
                    } catch {
                        debugError("❌ ID登录 Ticket 获取失败: \(error)")
                        await send(.ticketResponse(.failure(APIError.networkError(error.localizedDescription))))
                    }
                }
                
            case let .ticketResponse(.success(response)):
                state.isTicketLoading = false
                if response.isSuccess {
                    state.ticketError = nil
                    state.loginStep = .completed
                    
                                    debugInfo("✅ ID 登录完整流程成功")
                debugInfo("🎫 Ticket 获取成功: \(response.ticket ?? "nil")")
                    
                    // 更新 AccountModel 中的 ticket 并保存
                    if let ticket = response.ticket {
                        if var accountModel = state.accountModel {
                            accountModel.ticket = ticket
                            state.accountModel = accountModel
                            
                            // 保存完整的 AccountModel
                            UserInfoManager.saveAccountModel(accountModel)
                            
                            // 发送 Ticket 获取成功通知，触发导航到主页面
                            NotificationCenter.default.post(name: .ticketSuccess, object: nil)
                        } else {
                            debugError("❌ AccountModel 不存在，无法保存 ticket")
                            state.ticketError = "内部错误：账户信息丢失"
                            state.loginStep = .failed
                        }
                    } else {
                        state.ticketError = "Ticket 为空"
                        state.loginStep = .failed
                    }
                    
                } else {
                    state.ticketError = response.errorMessage
                    state.loginStep = .failed
                }
                return .none
                
            case let .ticketResponse(.failure(error)):
                state.isTicketLoading = false
                state.ticketError = error.localizedDescription
                state.loginStep = .failed
                debugError("❌ ID 登录 Ticket 获取失败: \(error.localizedDescription)")
                return .none
                
            case .clearTicketError:
                state.ticketError = nil
                return .none
                
            case .resetLogin:
                state.isLoading = false
                state.isTicketLoading = false
                state.errorMessage = nil
                state.ticketError = nil
                state.accountModel = nil  // 清除 AccountModel
                state.loginStep = .initial
                
                // 清除本地存储的认证信息
                UserInfoManager.clearAllAuthenticationData()
                
                return .none
            }
        }
    }
}