import { Dialect } from 'sequelize';
import { Sequelize } from 'sequelize-typescript';

import config from '../config';
import { DatabaseOptions } from '../utils/interfaces';
import { Address } from './address';
import { AddressBalanceLog } from './addressBalanceLog';
import { Balance } from './balance';
import { Block } from './block';
import { Check } from './check';
import { Coin } from './coin';
import { CoinContractAddress } from './coinContractAddress';
import { CoinLog } from './coinLog';
import { CoinVolume } from './coinVolume';
import { Counter } from './counter';
import { DelRateHistory1d } from './delRateHistory1d';
import { DelRateHistory1h } from './delRateHistory1h';
import { ErrorLog } from './errorLog';
import { EvmAccount } from './evmAccount';
import { EvmAccountERC20TokenBalance } from './evmAccountERC20TokenBalance';
import { EvmAccountERC721TokenBalance } from './evmAccountERC721TokenBalance';
import { EvmAccountERC1155TokenBalance } from './evmAccountERC1155TokenBalance';
import { EvmBlock } from './evmBlock';
import { EvmContract } from './evmContract';
import { EvmContractAction } from './evmContractAction';
import { EvmErrorLog } from './evmErrorLog';
import { EvmReceipt } from './evmReceipt';
import { EvmReceiptLog } from './evmReceiptLog';
import { EvmToken } from './evmToken';
import { EvmTokenEvent } from './evmTokenEvent';
import { EvmTokenType } from './evmTokenType';
import { EvmTokenTypeEvent } from './evmTokenTypeEvent';
import { EvmTransaction } from './evmTransaction';
import { Fee } from './fee';
import { InputBlock } from './inputBlock';
import { Legacy } from './legacy';
import { Address as LegacyAddress } from './legacyAddress';
import { Block as LegacyBlock } from './legacyBlock';
import { Coin as LegacyCoin } from './legacyCoin';
import { LegacyDscEvmAddress } from './legacyDscEvmAddress';
import { LegacyDscValidators } from './legacyDscValidators';
import { Multisig as LegacyMultiSig } from './legacyMultisig';
import { Nft as LegacyNft } from './legacyNft';
import { Reward as LegacyReward } from './legacyReward';
import { Tx as LegacyTx } from './legacyTx';
import { MultisendTx } from './multisendTx';
import { Multisig } from './multisig';
import { MultisigOwner } from './multisigOwner';
import { MultisigSign } from './multisigSign';
import { MultisigTx } from './multisigTx';
import { Nft } from './nft';
import { NftRedelegation } from './nftRedelegation';
import { NftReserve } from './nftReserve';
import { NftTransferHistory } from './nftTransferHistory';
import { History_1d } from './priceHistory/history1d';
import { History_1h } from './priceHistory/history1h';
import { History_1d as LegacyHistory_1d } from './priceHistory/legacyHistory1d';
import { History_1h as LegacyHistory_1h } from './priceHistory/legacyHistory1h';
import { Redelegation } from './redelegation';
import { RedelegationPart } from './redelegationPart';
import { RedelegationPartNft } from './redelegationPartNft';
import { Reward } from './reward';
import { Slash } from './slash';
import { SoftwareUpgradeProposal } from './softwareUpgradeProposal';
import { Stake } from './stake';
import { StakeNft } from './stakeNft';
import { StatHistory_1d as LegacyStatHistory_1d } from './statHistory/legacyStatHistory1d';
import { StatHistory_1d } from './statHistory/statHistory1d';
import { SwapChain } from './swapChain';
import { SwapMultiple } from './swapMultiple';
import { Tx } from './tx';
import { TxFee } from './txFee';
import { Undelegation } from './undelegation';
import { UndelegationNft } from './undelegationNft';
import { Validator } from './validator';
import { ValidatorStatus } from './validator-status';
import { ValidatorSkippedBlock } from './validatorSkippedBlock';
import { Worker } from './worker';

export { Address } from './address';
export { AddressBalanceLog } from './addressBalanceLog';
export { Balance } from './balance';
export { Block } from './block';
export { Check } from './check';
export { Coin } from './coin';
export { CoinContractAddress } from './coinContractAddress';
export { CoinLog } from './coinLog';
export { CoinVolume } from './coinVolume';
export { Counter } from './counter';
export { DelRateHistory1d } from './delRateHistory1d';
export { DelRateHistory1h } from './delRateHistory1h';
export { ErrorLog } from './errorLog';
export { EvmAccount } from './evmAccount';
export { EvmAccountERC20TokenBalance } from './evmAccountERC20TokenBalance';
export { EvmAccountERC721TokenBalance } from './evmAccountERC721TokenBalance';
export { EvmAccountERC1155TokenBalance } from './evmAccountERC1155TokenBalance';
export { EvmBlock } from './evmBlock';
export { EvmContractAction } from './evmContractAction';
export { EvmContract } from './evmContract';
export { EvmErrorLog } from './evmErrorLog';
export { EvmReceipt } from './evmReceipt';
export { EvmReceiptLog } from './evmReceiptLog';
export { EvmToken } from './evmToken';
export { EvmTokenEvent } from './evmTokenEvent';
export { EvmTokenType } from './evmTokenType';
export { EvmTokenTypeEvent } from './evmTokenTypeEvent';
export { EvmTransaction } from './evmTransaction';
export { Fee } from './fee';
export { InputBlock } from './inputBlock';
export { Legacy } from './legacy';
export { Address as LegacyAddress } from './legacyAddress';
export { Block as LegacyBlock } from './legacyBlock';
export { Coin as LegacyCoin } from './legacyCoin';
export { LegacyDscEvmAddress } from './legacyDscEvmAddress';
export { LegacyDscValidators } from './legacyDscValidators';
export { Multisig as LegacyMultiSig } from './legacyMultisig';
export { Nft as LegacyNft } from './legacyNft';
export { Reward as LegacyReward } from './legacyReward';
export { Tx as LegacyTx } from './legacyTx';
export { MultisendTx } from './multisendTx';
export { Multisig } from './multisig';
export { MultisigOwner } from './multisigOwner';
export { MultisigSign } from './multisigSign';
export { MultisigTx } from './multisigTx';
export { Nft } from './nft';
export { NftRedelegation } from './nftRedelegation';
export { NftReserve } from './nftReserve';
export { NftTransferHistory } from './nftTransferHistory';
export { History_1d } from './priceHistory/history1d';
export { History_1h } from './priceHistory/history1h';
export { History_1d as LegacyHistory_1d } from './priceHistory/legacyHistory1d';
export { History_1h as LegacyHistory_1h } from './priceHistory/legacyHistory1h';
export { Redelegation } from './redelegation';
export { RedelegationPart } from './redelegationPart';
export { RedelegationPartNft } from './redelegationPartNft';
export { Reward } from './reward';
export { Slash } from './slash';
export { SoftwareUpgradeProposal } from './softwareUpgradeProposal';
export { Stake } from './stake';
export { StakeNft } from './stakeNft';
export { StatHistory_1d as LegacyStatHistory_1d } from './statHistory/legacyStatHistory1d';
export { StatHistory_1d } from './statHistory/statHistory1d';
export { SwapChain } from './swapChain';
export { SwapMultiple } from './swapMultiple';
export { Tx } from './tx';
export { TxFee } from './txFee';
export { Undelegation } from './undelegation';
export { UndelegationNft } from './undelegationNft';
export { Validator } from './validator';
export { ValidatorStatus } from './validator-status';
export { ValidatorSkippedBlock } from './validatorSkippedBlock';
export { Worker } from './worker';

// variables
const models = [
  AddressBalanceLog,
  Address,
  Balance,
  Block,
  Check,
  Coin,
  CoinContractAddress,
  CoinLog,
  CoinVolume,
  Counter,
  ErrorLog,
  Fee,
  History_1h,
  EvmAccount,
  EvmBlock,
  EvmTransaction,
  EvmReceipt,
  EvmReceiptLog,
  EvmContract,
  EvmContractAction,
  EvmToken,
  EvmTokenType,
  EvmTokenEvent,
  EvmAccountERC20TokenBalance,
  EvmAccountERC721TokenBalance,
  EvmAccountERC1155TokenBalance,
  EvmTokenTypeEvent,
  EvmErrorLog,
  History_1d,
  StatHistory_1d,
  Multisig,
  MultisigSign,
  MultisigTx,
  MultisendTx,
  MultisigOwner,
  Nft,
  NftReserve,
  NftTransferHistory,
  Reward,
  Slash,
  Stake,
  StakeNft,
  SwapChain,
  SwapMultiple,
  Tx,
  TxFee,
  Validator,
  ValidatorStatus,
  ValidatorSkippedBlock,
  SoftwareUpgradeProposal,
  Legacy,
  LegacyDscEvmAddress,
  LegacyDscValidators,
  Redelegation,
  NftRedelegation,
  RedelegationPart,
  RedelegationPartNft,
  Undelegation,
  UndelegationNft,
  DelRateHistory1h,
  DelRateHistory1d,
];

const legacyModels = [
  LegacyTx,
  LegacyBlock,
  LegacyNft,
  LegacyCoin,
  LegacyReward,
  LegacyMultiSig,
  LegacyAddress,
  LegacyHistory_1d,
  LegacyHistory_1h,
  LegacyStatHistory_1d,
];

const indexerModels = [InputBlock, Worker];

export function initDatabase(databaseOptions: DatabaseOptions) {
  try {
    const {
      dbLink = null,
      archiveDBLink = null,
      indexerLink = null,
      logging = false,
      sync = false,
      dialect = config.dialectOptions.name as Dialect,
      txTimeout = config.dialectOptions.txTimeout as number,
      baseCoin,
      timestamps = false,
      timestampsIndexer = true,
      timestampsArchiveDB = false,
    } = databaseOptions;

    let sequelize: Sequelize = null;
    let sequelizeArchiveParser: Sequelize = null;
    let sequelizeIndexer: Sequelize = null;

    if (baseCoin) {
      config.baseCoin = baseCoin;
    }

    if (dbLink) {
      sequelize = new Sequelize(dbLink, {
        dialect,
        models,
        logging,
        pool: config.pool,
        dialectOptions: {
          idle_in_transaction_session_timeout: txTimeout,
        },
        define: {
          timestamps,
        },
      });
    }

    if (archiveDBLink) {
      sequelizeArchiveParser = new Sequelize(archiveDBLink, {
        dialect,
        models: legacyModels,
        logging,
        pool: config.pool,
        dialectOptions: {
          idle_in_transaction_session_timeout: txTimeout,
        },
        define: {
          timestamps: timestampsArchiveDB,
        },
      });
    }

    if (indexerLink) {
      sequelizeIndexer = new Sequelize(indexerLink, {
        dialect,
        models: indexerModels,
        logging,
        define: {
          timestamps: timestampsIndexer,
        },
      });
    }

    if (sync) {
      sequelize && sequelize.sync();
      sequelizeIndexer && sequelizeIndexer.sync();
      sequelizeArchiveParser && sequelizeArchiveParser.sync();
    }

    return {
      sequelize,
      sequelizeIndexer,
      sequelizeArchiveParser,
    };
  } catch (e) {
    console.error(e);

    throw new Error(`An error occurred during the initialization of the database. ${e.message}`);
  }
}