import Combine

final class AccountsMiddleware {
    static let shared = AccountsMiddleware()

    func middleware(state: AppState, action: AppAction) -> AnyPublisher<AppAction, Never> {
        switch action {
        case .databaseAction(.storedAccountsLoaded(let accounts)):
            return Just(.accountsAction(.accountsListUpdated(accounts: accounts)))
                .eraseToAnyPublisher()

        case .xmppAction(.clientConnectionChanged(let jid, let connectionStatus)):
            return Future<AppAction, Never> { promise in
                guard let account = state.accountsState.accounts.first(where: { $0.bareJid == jid }) else {
                    promise(.success(.empty("Account not found for jid \(jid)")))
                    return
                }
                if account.isTemp {
                    switch connectionStatus {
                    case .connected:
                        promise(.success(.accountsAction(.makeAccountPermanent(account: account))))

                    case .disconnected(let reason):
                        if reason != "No error!" {
                            promise(.success(.accountsAction(.addAccountError(jid: jid, reason: reason))))
                        } else {
                            promise(.success(.empty("Account disconnected with no error")))
                        }

                    default:
                        promise(.success(.empty("Account connection status changed to \(connectionStatus)")))
                    }
                } else {
                    promise(.success(.empty("Account is not temporary, ignoring")))
                }
            }
            .eraseToAnyPublisher()

        default:
            return Empty().eraseToAnyPublisher()
        }
    }
}