HomeFeature.swift

import AppCore
import Combine
import ComposableArchitecture
import ComposablePresentation
import Foundation
import RegisterFeature
import XXClient
import XXMessengerClient

public struct HomeState: Equatable {
  public init(
    failure: String? = nil,
    register: RegisterState? = nil,
    alert: AlertState<HomeAction>? = nil,
    isDeletingAccount: Bool = false
  ) {
    self.failure = failure
    self.register = register
    self.alert = alert
    self.isDeletingAccount = isDeletingAccount
  }

  public var failure: String?
  public var register: RegisterState?
  public var alert: AlertState<HomeAction>?
  public var isDeletingAccount: Bool
}

public enum HomeAction: Equatable {
  public enum Messenger: Equatable {
    case start
    case didStartRegistered
    case didStartUnregistered
    case failure(NSError)
  }

  public enum DeleteAccount: Equatable {
    case buttonTapped
    case confirmed
    case success
    case failure(NSError)
  }

  case messenger(Messenger)
  case deleteAccount(DeleteAccount)
  case didDismissAlert
  case didDismissRegister
  case register(RegisterAction)
}

public struct HomeEnvironment {
  public init(
    messenger: Messenger,
    db: DBManagerGetDB,
    mainQueue: AnySchedulerOf<DispatchQueue>,
    bgQueue: AnySchedulerOf<DispatchQueue>,
    register: @escaping () -> RegisterEnvironment
  ) {
    self.messenger = messenger
    self.db = db
    self.mainQueue = mainQueue
    self.bgQueue = bgQueue
    self.register = register
  }

  public var messenger: Messenger
  public var db: DBManagerGetDB
  public var mainQueue: AnySchedulerOf<DispatchQueue>
  public var bgQueue: AnySchedulerOf<DispatchQueue>
  public var register: () -> RegisterEnvironment
}

extension HomeEnvironment {
  public static let unimplemented = HomeEnvironment(
    messenger: .unimplemented,
    db: .unimplemented,
    mainQueue: .unimplemented,
    bgQueue: .unimplemented,
    register: { .unimplemented }
  )
}

public let homeReducer = Reducer<HomeState, HomeAction, HomeEnvironment>
{ state, action, env in
  switch action {
  case .messenger(.start):
    return .result {
      do {
        try env.messenger.start()

        if env.messenger.isConnected() == false {
          try env.messenger.connect()
        }

        if env.messenger.isLoggedIn() == false {
          if try env.messenger.isRegistered() == false {
            return .success(.messenger(.didStartUnregistered))
          }
          try env.messenger.logIn()
        }

        return .success(.messenger(.didStartRegistered))
      } catch {
        return .success(.messenger(.failure(error as NSError)))
      }
    }
    .subscribe(on: env.bgQueue)
    .receive(on: env.mainQueue)
    .eraseToEffect()

  case .messenger(.didStartUnregistered):
    state.register = RegisterState()
    return .none

  case .messenger(.didStartRegistered):
    return .none

  case .messenger(.failure(let error)):
    state.failure = error.localizedDescription
    return .none

  case .deleteAccount(.buttonTapped):
    state.alert = .confirmAccountDeletion()
    return .none

  case .deleteAccount(.confirmed):
    state.isDeletingAccount = true
    return .result {
      do {
        let contactId = try env.messenger.e2e.tryGet().getContact().getId()
        let contact = try env.db().fetchContacts(.init(id: [contactId])).first
        if let username = contact?.username {
          let ud = try env.messenger.ud.tryGet()
          try ud.permanentDeleteAccount(username: Fact(fact: username, type: 0))
        }
        try env.messenger.destroy()
        try env.db().drop()
        return .success(.deleteAccount(.success))
      } catch {
        return .success(.deleteAccount(.failure(error as NSError)))
      }
    }
    .subscribe(on: env.bgQueue)
    .receive(on: env.mainQueue)
    .eraseToEffect()

  case .deleteAccount(.success):
    state.isDeletingAccount = false
    return .none

  case .deleteAccount(.failure(let error)):
    state.isDeletingAccount = false
    state.alert = .accountDeletionFailed(error)
    return .none

  case .didDismissAlert:
    state.alert = nil
    return .none

  case .didDismissRegister:
    state.register = nil
    return .none

  case .register(.finished):
    state.register = nil
    return Effect(value: .messenger(.start))

  case .register(_):
    return .none
  }
}
.presenting(
  registerReducer,
  state: .keyPath(\.register),
  id: .notNil(),
  action: /HomeAction.register,
  environment: { $0.register() }
)