// Copyright 2024 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only

import semver from 'semver';
import { last } from 'lodash';

import * as durations from '../util/durations';
import { clearTimeoutIfNecessary } from '../util/clearTimeoutIfNecessary';
import * as Registration from '../util/registration';
import * as log from '../logging/log';
import * as Errors from '../types/errors';
import { HTTPError } from '../textsecure/Errors';
import { drop } from '../util/drop';
import { strictAssert } from '../util/assert';
import type { MessageAttributesType } from '../model-types';
import { ReadStatus } from '../messages/MessageReadStatus';
import { incrementMessageCounter } from '../util/incrementMessageCounter';
import { SeenStatus } from '../MessageSeenStatus';
import { saveNewMessageBatcher } from '../util/messageBatcher';
import { generateMessageId } from '../util/generateMessageId';
import { BodyRange } from '../types/BodyRange';
import * as RemoteConfig from '../RemoteConfig';
import { isBeta, isProduction } from '../util/version';
import type {
  ReleaseNotesManifestResponseType,
  ReleaseNoteResponseType,
} from '../textsecure/WebAPI';
import type { WithRequiredProperties } from '../types/Util';

const FETCH_INTERVAL = 3 * durations.DAY;
const ERROR_RETRY_DELAY = 3 * durations.HOUR;
const NEXT_FETCH_TIME_STORAGE_KEY = 'releaseNotesNextFetchTime';
const PREVIOUS_MANIFEST_HASH_STORAGE_KEY = 'releaseNotesPreviousManifestHash';
const VERSION_WATERMARK_STORAGE_KEY = 'releaseNotesVersionWatermark';

type MinimalEventsType = {
  on(event: 'timetravel', callback: () => void): void;
};

type ManifestReleaseNoteType = WithRequiredProperties<
  ReleaseNotesManifestResponseType['announcements'][0],
  'desktopMinVersion'
>;

export type ReleaseNoteType = ReleaseNoteResponseType &
  Pick<ReleaseNotesManifestResponseType['announcements'][0], 'ctaId' | 'link'>;

let initComplete = false;

export class ReleaseNotesFetcher {
  private timeout: NodeJS.Timeout | undefined;
  private isRunning = false;

  protected async scheduleUpdateForNow(): Promise<void> {
    const now = Date.now();
    await window.textsecure.storage.put(NEXT_FETCH_TIME_STORAGE_KEY, now);
  }

  protected setTimeoutForNextRun(): void {
    const now = Date.now();
    const time = window.textsecure.storage.get(
      NEXT_FETCH_TIME_STORAGE_KEY,
      now
    );

    log.info(
      'ReleaseNotesFetcher: Next update scheduled for',
      new Date(time).toISOString()
    );

    let waitTime = time - now;
    if (waitTime < 0) {
      waitTime = 0;
    }

    clearTimeoutIfNecessary(this.timeout);
    this.timeout = setTimeout(() => this.runWhenOnline(), waitTime);
  }

  private getOrInitializeVersionWatermark(): string {
    const versionWatermark = window.textsecure.storage.get(
      VERSION_WATERMARK_STORAGE_KEY
    );
    if (versionWatermark) {
      return versionWatermark;
    }

    log.info(
      'ReleaseNotesFetcher: Initializing version high watermark to current version'
    );
    const currentVersion = window.getVersion();
    drop(
      window.textsecure.storage.put(
        VERSION_WATERMARK_STORAGE_KEY,
        currentVersion
      )
    );
    return currentVersion;
  }

  private async getReleaseNote(
    note: ManifestReleaseNoteType
  ): Promise<ReleaseNoteType | undefined> {
    if (!window.textsecure.server) {
      return undefined;
    }

    const { uuid, ctaId, link } = note;
    const result = await window.textsecure.server.getReleaseNote({
      uuid,
    });
    strictAssert(
      result.uuid === uuid,
      'UUID of localized release note should match requested UUID'
    );

    return {
      ...result,
      uuid,
      ctaId,
      link,
    };
  }

  private async processReleaseNotes(
    notes: ReadonlyArray<ManifestReleaseNoteType>
  ): Promise<void> {
    const sortedNotes = [...notes].sort(
      (a: ManifestReleaseNoteType, b: ManifestReleaseNoteType) =>
        semver.compare(a.desktopMinVersion, b.desktopMinVersion)
    );
    const hydratedNotes = [];
    for (const note of sortedNotes) {
      // eslint-disable-next-line no-await-in-loop
      hydratedNotes.push(await this.getReleaseNote(note));
    }
    if (!hydratedNotes.length) {
      log.warn('ReleaseNotesFetcher: No hydrated notes available, stopping');
      return;
    }

    log.info('ReleaseNotesFetcher: Ensuring Signal conversation');
    const signalConversation =
      await window.ConversationController.getOrCreateSignalConversation();

    const messages: Array<MessageAttributesType> = [];
    hydratedNotes.forEach(async (note, index) => {
      if (!note) {
        return;
      }

      const { title, body } = note;
      const messageBody = `${title}\n\n${body}`;
      const bodyRanges = [
        { start: 0, length: title.length, style: BodyRange.Style.BOLD },
      ];
      const timestamp = Date.now() + index;

      const message: MessageAttributesType = {
        ...generateMessageId(incrementMessageCounter()),
        body: messageBody,
        bodyRanges,
        conversationId: signalConversation.id,
        readStatus: ReadStatus.Unread,
        seenStatus: SeenStatus.Unseen,
        received_at_ms: timestamp,
        sent_at: timestamp,
        serverTimestamp: timestamp,
        sourceDevice: 1,
        sourceServiceId: signalConversation.getServiceId(),
        timestamp,
        type: 'incoming',
      };

      window.MessageCache.toMessageAttributes(message);
      signalConversation.trigger('newmessage', message);

      messages.push(message);
    });

    await Promise.all(
      messages.map(message => saveNewMessageBatcher.add(message))
    );

    signalConversation.set({ active_at: Date.now(), isArchived: false });
    drop(signalConversation.updateUnread());

    const newestNote = last(sortedNotes);
    strictAssert(newestNote, 'processReleaseNotes requires at least 1 note');

    const versionWatermark = newestNote.desktopMinVersion;
    log.info(
      `ReleaseNotesFetcher: Updating version watermark to ${versionWatermark}`
    );
    drop(
      window.textsecure.storage.put(
        VERSION_WATERMARK_STORAGE_KEY,
        versionWatermark
      )
    );
  }

  private async scheduleForNextRun(): Promise<void> {
    const now = Date.now();
    const nextTime = now + FETCH_INTERVAL;
    await window.textsecure.storage.put(NEXT_FETCH_TIME_STORAGE_KEY, nextTime);
  }

  private async run(): Promise<void> {
    if (this.isRunning) {
      log.warn('ReleaseNotesFetcher: Already running, preventing reentrancy');
      return;
    }

    this.isRunning = true;
    log.info('ReleaseNotesFetcher: Starting');
    try {
      const versionWatermark = this.getOrInitializeVersionWatermark();
      log.info(`ReleaseNotesFetcher: Version watermark is ${versionWatermark}`);

      if (!window.textsecure.server) {
        log.info('ReleaseNotesFetcher: WebAPI unavailable');
        throw new Error('WebAPI unavailable');
      }

      const hash = await window.textsecure.server.getReleaseNotesManifestHash();
      if (!hash) {
        throw new Error('Release notes manifest hash missing');
      }

      const previousHash = window.textsecure.storage.get(
        PREVIOUS_MANIFEST_HASH_STORAGE_KEY
      );
      if (hash !== previousHash) {
        log.info('ReleaseNotesFetcher: Manifest hash changed, fetching');
        const manifest =
          await window.textsecure.server.getReleaseNotesManifest();
        const validNotes = manifest.announcements.filter(
          (note): note is ManifestReleaseNoteType =>
            note.desktopMinVersion != null &&
            semver.gt(note.desktopMinVersion, versionWatermark)
        );
        if (validNotes.length) {
          log.info(
            `ReleaseNotesFetcher: Processing ${validNotes.length} new release notes`
          );
          drop(this.processReleaseNotes(validNotes));
        } else {
          log.info('ReleaseNotesFetcher: No new release notes');
        }

        drop(
          window.textsecure.storage.put(
            PREVIOUS_MANIFEST_HASH_STORAGE_KEY,
            hash
          )
        );
      } else {
        log.info('ReleaseNotesFetcher: Manifest hash unchanged');
      }

      await this.scheduleForNextRun();
      this.setTimeoutForNextRun();
    } catch (error) {
      const errorString =
        error instanceof HTTPError
          ? error.code.toString()
          : Errors.toLogFormat(error);
      log.error(
        `ReleaseNotesFetcher: Error, trying again later. ${errorString}`
      );
      setTimeout(() => this.setTimeoutForNextRun(), ERROR_RETRY_DELAY);
    } finally {
      this.isRunning = false;
    }
  }

  private runWhenOnline() {
    if (window.textsecure.server?.isOnline()) {
      drop(this.run());
    } else {
      log.info(
        'ReleaseNotesFetcher: We are offline; will fetch when we are next online'
      );
      const listener = () => {
        window.Whisper.events.off('online', listener);
        this.setTimeoutForNextRun();
      };
      window.Whisper.events.on('online', listener);
    }
  }

  public static async init(
    events: MinimalEventsType,
    isNewVersion: boolean
  ): Promise<void> {
    if (initComplete || !this.isEnabled()) {
      return;
    }

    initComplete = true;

    const listener = new ReleaseNotesFetcher();

    if (isNewVersion) {
      await listener.scheduleUpdateForNow();
    }
    listener.setTimeoutForNextRun();

    events.on('timetravel', () => {
      if (Registration.isDone()) {
        listener.setTimeoutForNextRun();
      }
    });
  }

  public static isEnabled(): boolean {
    const version = window.getVersion();

    if (isProduction(version)) {
      return RemoteConfig.isEnabled('desktop.releaseNotes');
    }

    if (isBeta(version)) {
      return RemoteConfig.isEnabled('desktop.releaseNotes.beta');
    }

    return RemoteConfig.isEnabled('desktop.releaseNotes.dev');
  }
}