/*
 This file is part of GNU Taler
 (C) 2019 GNUnet e.V.

 GNU Taler is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software
 Foundation; either version 3, or (at your option) any later version.

 GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along with
 GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */

/**
 * Common interface of the internal wallet state.  This object is passed
 * to the various operations (exchange management, withdrawal, refresh, reserve
 * management, etc.).
 *
 * Some operations can be accessed via this state object.  This allows mutual
 * recursion between operations, without having cyclic dependencies between
 * the respective TypeScript files.
 *
 * (You can think of this as a "header file" for the wallet implementation.)
 */

/**
 * Imports.
 */
import { IDBFactory } from "@gnu-taler/idb-bridge";
import {
  DenominationInfo,
  TransactionState,
  WalletNotification,
} from "@gnu-taler/taler-util";
import { HttpRequestLibrary } from "@gnu-taler/taler-util/http";
import { TalerCryptoInterface } from "./crypto/cryptoImplementation.js";
import {
  WalletDbAllStoresReadOnlyTransaction,
  WalletDbReadOnlyTransaction,
  WalletDbReadWriteTransaction,
  WalletStoresV1,
} from "./db.js";
import { TaskScheduler } from "./shepherd.js";
import { DbAccess } from "./query.js";
import { TimerGroup } from "./util/timer.js";
import { WalletConfig } from "./wallet-api-types.js";

export const EXCHANGE_COINS_LOCK = "exchange-coins-lock";
export const EXCHANGE_RESERVES_LOCK = "exchange-reserves-lock";

export interface TrustInfo {
  isTrusted: boolean;
  isAudited: boolean;
}

export interface MerchantInfo {
  protocolVersionCurrent: number;
}

export interface RecoupOperations {
  createRecoupGroup(
    ws: InternalWalletState,
    tx: WalletDbReadWriteTransaction<
      ["recoupGroups", "denominations", "refreshGroups"]
    >,
    exchangeBaseUrl: string,
    coinPubs: string[],
  ): Promise<string>;
}

export type NotificationListener = (n: WalletNotification) => void;

export type CancelFn = () => void;

/**
 * Internal, shared wallet state that is used by the implementation
 * of wallet operations.
 *
 * FIXME:  This should not be exported anywhere from the taler-wallet-core package,
 * as it's an opaque implementation detail.
 */
export interface InternalWalletState {
  cryptoApi: TalerCryptoInterface;

  timerGroup: TimerGroup;
  stopped: boolean;

  config: Readonly<WalletConfig>;

  taskScheduler: TaskScheduler;

  listeners: NotificationListener[];

  initCalled: boolean;

  merchantInfoCache: Record<string, MerchantInfo>;

  recoupOps: RecoupOperations;

  isTaskLoopRunning: boolean;

  getTransactionState(
    ws: InternalWalletState,
    tx: WalletDbAllStoresReadOnlyTransaction,
    transactionId: string,
  ): Promise<TransactionState | undefined>;

  getDenomInfo(
    ws: InternalWalletState,
    tx: WalletDbReadOnlyTransaction<["denominations"]>,
    exchangeBaseUrl: string,
    denomPubHash: string,
  ): Promise<DenominationInfo | undefined>;

  ensureWalletDbOpen(): Promise<void>;

  idb: IDBFactory;
  db: DbAccess<typeof WalletStoresV1>;
  http: HttpRequestLibrary;

  notify(n: WalletNotification): void;

  addNotificationListener(f: (n: WalletNotification) => void): CancelFn;

  /**
   * Stop ongoing processing.
   */
  stop(): void;

  /**
   * Run an async function after acquiring a list of locks, identified
   * by string tokens.
   */
  runSequentialized<T>(tokens: string[], f: () => Promise<T>): Promise<T>;

  /**
   * Ensure that a task loop is currently running.
   * Starts one if no task loop is running.
   */
  ensureTaskLoopRunning(): void;
}