// Redux state
export type Threads = { [threadId: string]: Thread };
export type Messages = { [threadId: string]: Message[] };
export type LocalMessages = { [threadId: string]: LocalMessage[] };

// Redux saga - reconcilation logic that listens on any message dispatch action
export function* watchMessagesSaga() {
  // We don't care about every message update, only the latest ones batched together. takeLatest will cancel any previous in-flight updates.
  yield takeLatest(MessageActions, reconcileRemoteAndLocalMessagesSaga);
}

function* reconcileRemoteAndLocalMessagesSaga(action: MessageAction) {
  const allRemoteMessages = yield* selectTyped(selectMessages);
  const allLocalMessages = yield* selectTyped(selectLocalMessages);
  const threadsToUpdate = getConvoIdsToUpdate(action);

  for (const threadId of threadsToUpdate) {
    const remoteMessages = allRemoteMessages[threadId] ?? [];
    const localMessages = allLocalMessages[threadId] ?? [];

    const newLocalMessages = reconcileLocalAndRemoteMessages(
      localMessages,
      remoteMessages
    );

    yield put(
      setLocalMessagesForThread({ threadId, localMessages: newLocalMessages })
    );
  
}

/**
 * Combine local and remote messages, only keep the local message if it has not yet been replaced with a remote message
 * Returns all messages (local and remote) sorted by timestamp
 */
export const reconcileLocalAndRemoteMessages = (
  localMessages: LocalMessage[],
  remoteMessages: ReduxMessage[]
): LocalMessage[] => {
  const remoteUnconfirmedMessageIds = new Set(
    remoteMessages.map((msg) => msg.attributes.messageId)
  );

  const remoteConfirmedMessageIds = new Set(
    remoteMessages.map((msg) => msg.sid)
  );

  /**
   * We construct the local message with a temporary id, which is replaced by a server-side ID when the message is confirmed.
   * We store the locally generated message id in the message attributes for future matching.
   *
   * Case 1: LocalMessage has not been replaced yet with remoteMessage, compare id with set of unconfirmed remote message ids
   * Case 2: LocalMessage already replaced with remoteMessage, compare id with set of confirmed remote message ids
   */
  const remainingLocalMessages = localMessages.filter(
    (localMessage) =>
      localMessage.unconfirmed &&
      !remoteUnconfirmedMessageIds.has(localMessage.id) &&
      !remoteConfirmedMessageIds.has(localMessage.id)
  );

  return [
    ...convertReduxToLocalMessages(remoteMessages),
    ...remainingLocalMessages,
  ].sort(sortLocalMessagesFnAsc);
};

/**
 * Abstraction around our WebSocket client that handles queuing for offline-first support
 */
export abstract class BaseChatManager {
  client: WebSocketClient | null = null;

  /** Connection promise that will only resolve when the SDK client is in the connected state */
  private connectionState: ConnectionState = "unknown";

  /**
   * Turns the connection state into a promise that can be awaited to queue on a connected state.
   */
  private waitForConnection: Promise<void>;
  private waitForConnectionResolve:
    | ((value: void | PromiseLike<void>) => void)
    | undefined;
  private waitForConnectionReject:
    | ((reason?: ChatManagerRejectedError) => void)
    | undefined;

  public constructor() {
    this.createConnectionPromise()
  }

  public releaseClient() {
    // Reject awaiting callers
    if (this.waitForInitializedReject) {
      this.waitForInitializedReject(
        new ChatManagerRejectedError("[BaseChatManager] Releasing client")
      );
      this.waitForInitializedReject = undefined;
      this.waitForInitializedResolve = undefined;
    }
    if (this.waitForConnectionReject) {
      this.waitForConnectionReject(
        new ChatManagerRejectedError("[BaseChatManager] Releasing client")
      );
      this.waitForConnectionReject = undefined;
      this.waitForConnectionResolve = undefined;
    }
    this.createConnectionPromise()
  }

  /**
   * Wrap SDK actions in this to ensure the function waits on the connection to the SDK.
   */
  private wrapAction<Args extends unknown[], Return>(
    fn: (this: BaseChatManager, ...args: Args) => Promise<Return>,
    functionName: string,
  ) {
    return async (...args: Args): Promise<Return> => {
      // Create a bound version of the function with the correct this context and client
      // The bound function is what awaits so that we still detect disconnects in between retries
      const appliedFn = async () => {
        // NOTE: we don't want to call await this.waitForConnection and kick it to the promise chain if we don't have to
        // So we check if connectionState is not "connected" first
        if (this.connectionState !== "connected") {
          await this.waitForConnection;
        }
        return fn.call(this, ...args);
      };

      return await retryAsyncFn(
        appliedFn,
        functionName
      );
    };
  }

  private createConnectionPromise() {
	  this.waitForConnection = new Promise((resolve, reject) => {
      this.waitForConnectionResolve = resolve;
      this.waitForConnectionReject = reject;
    });
  }
  
  private setConnectionState(state: ConnectionState) {
    // Resolve the existing connection promise if the state is connected
    if (this.waitForConnectionResolve && state === "connected") {
      this.waitForConnectionResolve();
      this.waitForConnectionResolve = undefined;
      this.waitForConnectionReject = undefined;
      // Leave the connection promise in a resolved state but release the resolve/reject functions so they can't be called again.
    }
    this.connectionState = state;
    this.handleConnectionStateChanged(state);
  }
  
  private onDisconnected() {
    this.handleDisconnected();
    // Reject the existing connection promises if they exist (there shouldn't be any if we were connected then went to a disconnected state)
    if (this.waitForConnectionReject) {
      this.waitForConnectionReject(
        new ChatManagerRejectedError("[BaseChatManager] Disconnected")
      );
      this.waitForConnectionReject = undefined;
      this.waitForConnectionResolve = undefined;
    }

    // Create a new connection promise for the next time waitForConnection() is called
    this.createConnectionPromise()
  }
  
  /**
   * onConnectionStateChanged is called each time the websocket client detects a connection state change.
   * It may receive duplicate events.
   */
  private onConnectionStateChanged(newState: ConnectionState) {
    if (newState === this.connectionState) {
      return;
    }
    if (
      this.connectionState === "connected" &&
      DISCONNECTED_STATES.includes(newState)
    ) {
      this.onDisconnected();
    }

    this.setConnectionState(newState);
  }

  /**
   * Example implementation of a function that awaits connection before proceeding.
   */
  public getLastMessageReadIndexForThread = this.wrapAction(
    async function GetLastMessageReadIndexForThread(threadId: string) {
      return await this.client.getLastMessageReadIndexForThread(threadId);
    },
    "GetLastMessageReadIndexForThread"
  );
}