/*!
 * @license
 * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
 */
import { injectable } from 'inversify';
import 'reflect-metadata';
import {
  AttributeValue,
  BatchWriteItemCommand,
  DeleteItemCommand,
  DeleteItemCommandInput,
  DynamoDBClient,
  GetItemCommand,
  GetItemCommandInput,
  PutItemCommand,
  QueryCommand,
  QueryCommandOutput,
  UpdateItemCommand,
  UpdateItemCommandInput,
} from '@aws-sdk/client-dynamodb';
import { BaseDto, BaseItem, ListParameters } from '../../job/model/Base/Base';

/**
 * Generic abstract class for representing repositories interacting with DynamoDB.
 * @export
 * @abstract
 * @class Repository
 * @template T The entity definition.
 * @template U The corresponding DB record attributes for the entity.
 */
@injectable()
export abstract class Repository<T extends BaseItem, U extends BaseDto, SK extends Partial<T>> {
  public constructor(
    protected dynamoDbClient: DynamoDBClient,
    protected tableName: string,
    protected pk: string,
  ) {}

  /**
   * Save item into database.
   * @abstract
   * @param {*} input The item to store.
   * @returns {Promise<T>} The item stored.
   * @memberof Repository
   */
  async create(input: T): Promise<T> {
    const dynamoDbRecord = this.convertToDynamoDbItem(input);

    await this.dynamoDbClient.send(
      new PutItemCommand({
        Item: dynamoDbRecord,
        TableName: this.tableName,
      }),
    );

    return input;
  }

  /**
   * Get one record from database.
   * @abstract
   * @param {string} sk The sort key used to identify the record.
   * @returns {Promise<T | null>} The retrieved record.
   * @memberof Repository
   */
  async findOne(sk: SK): Promise<T | null> {
    const params: GetItemCommandInput = {
      Key: {
        pk: { S: this.pk },
        sk: { S: this.buildSk(sk) },
      },
      TableName: this.tableName,
    };
    const res = await this.dynamoDbClient.send(new GetItemCommand(params));
    return res.Item ? this.convertToItem(res.Item as U) : null;
  }

  /**
   * Get list of records from database.
   * @abstract
   * @returns {Promise<Array<T>>} The retrieved records.
   * @memberof Repository
   */
  async list(parameters: ListParameters<never> = {}): Promise<Array<T>> {
    // Apply pagination for the scan.
    // By default, the Scan operation processes data sequentially.
    // DynamoDB returns data in increments of 1 MB increments.

    let startKey: Record<string, AttributeValue> | undefined = undefined; /* Indicator of where to paginate from. */
    const results: Array<Record<string, AttributeValue>> = [];

    // Iterate through pages until no more results are found.
    do {
      const res: QueryCommandOutput = await this.dynamoDbClient.send(
        new QueryCommand({
          ExpressionAttributeNames: {
            '#pk': 'pk',
          },
          ExpressionAttributeValues: {
            ':pk': { S: this.pk },
          },
          KeyConditionExpression: '#pk = :pk',
          TableName: this.tableName,
          ExclusiveStartKey: startKey,
          Limit: parameters.limit,
          ConsistentRead: parameters.consistentRead,
        }),
      );

      results.push(...(res.Items ?? []));
      startKey = res.LastEvaluatedKey;

      if (parameters.limit !== undefined && results.length >= parameters.limit) {
        // Truncate list to max requested items, stop querying.
        results.length = parameters.limit;
        break;
      }
    } while (startKey);

    return results.length ? results.map((item) => this.convertToItem(item as U)) : [];
  }

  /**
   * Update record in database.
   * @param {string} sk The sort key used to identify the record.
   * @param {Partial<T>} input The (partial) record to update (properties used in the SK cannot be updated).
   * @returns {Promise<T | null>} The updated record.
   * @memberof Repository
   */
  async update(sk: SK, input: Partial<Omit<T, keyof SK>>): Promise<T> {
    // Initialise update command
    const updateParams: UpdateItemCommandInput = {
      Key: {
        pk: { S: this.pk },
        sk: { S: this.buildSk(sk) },
      },
      ReturnValues: 'ALL_NEW',
      TableName: this.tableName,
    };

    const expressionAttributeNames: Record<string, string> = {};
    const expressionAttributeValues: Record<string, AttributeValue> = {};

    // To avoid conflict with reserved keywords, refer to attributes with an additional '#' prefix
    for (const key of Object.keys(input)) {
      if (input[key as keyof Partial<Omit<T, keyof SK>>] === null) {
        expressionAttributeNames[`#${key}`] = key;
        expressionAttributeValues[`:${key}`] = { NULL: true };
      } else {
        const val: string = input[key as keyof Partial<Omit<T, keyof SK>>] as string;
        expressionAttributeNames[`#${key}`] = key;
        expressionAttributeValues[`:${key}`] = { S: val };
      }
    }

    const updateExpressionPairs = Object.keys(input).map((key) => `#${key} = :${key}`);
    const updateExpression = `SET ${updateExpressionPairs.join(', ')}`;

    updateParams.ExpressionAttributeNames = expressionAttributeNames;
    updateParams.ExpressionAttributeValues = expressionAttributeValues;
    updateParams.UpdateExpression = updateExpression;

    const updateItemCommand = new UpdateItemCommand(updateParams);
    const updatedRecord = await this.dynamoDbClient.send(updateItemCommand);

    return this.convertToItem(updatedRecord.Attributes as U);
  }

  /**
   * Delete record from database.
   * @abstract
   * @param {string} sk The sort key used to identify the record.
   * @returns {void}
   * @memberof Repository
   */
  async delete(sk: T | SK): Promise<void> {
    const deleteCommandParams: DeleteItemCommandInput = {
      Key: {
        pk: { S: this.pk },
        sk: { S: this.buildSk(sk) },
      },
      TableName: this.tableName,
    };

    await this.dynamoDbClient.send(new DeleteItemCommand(deleteCommandParams));
    return;
  }

  async batchDelete<TItem extends T | SK>(sk: Array<TItem>): Promise<{ unprocessedItems: Array<TItem> }> {
    if (sk.length === 0) {
      return { unprocessedItems: [] };
    }

    const skMap: Record<string, TItem> = {};

    sk.forEach((sk) => {
      skMap[this.buildSk(sk)] = sk;
    });

    const result = await this.dynamoDbClient.send(
      new BatchWriteItemCommand({
        RequestItems: {
          [this.tableName]: Object.keys(skMap).map((sk) => ({
            DeleteRequest: {
              Key: {
                pk: { S: this.pk },
                sk: { S: sk },
              },
            },
          })),
        },
      }),
    );

    return {
      unprocessedItems:
        result.UnprocessedItems?.[this.tableName]?.map((item) => {
          const sk = item.DeleteRequest?.Key?.sk.S;

          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
          return skMap[sk!];
        }) || [],
    };
  }

  /**
   * Convert the DynanomDB attributes of the entity into a DynamoDB item.
   * @abstract
   * @param {T} item The DynamoDB item attributes to convert.
   * @returns {Record<keyof U, AttributeValue>} The DynamoDB record.
   * @memberof Repository
   */
  protected abstract convertToDynamoDbItem(item: T): Record<keyof U, AttributeValue>;

  /**
   * Convert DynamoDB item to entity.
   * @abstract
   * @param {Record<string, AttributeValue>} record The record to convert.
   * @returns {T} The converted entity.
   * @memberof Repository
   */
  protected abstract convertToItem(record: U): T;

  /**
   * Converts a sort key to a string for querying/putting in Dynamo.
   * @param {SK} sk
   * @return {string}
   * @protected
   */
  protected abstract buildSk(sk: T | SK): string;
}