import { ClassError, ObjectBase } from '@tomei/general';
import { LoginUser } from '@tomei/sso';
import { ActionEnum, Activity } from '@tomei/activity-history';
import { IHirerChangeRequestRemoveHirerAttr } from '../../interfaces/hirer-change-request-remove-hirer-attr.interface';
import { HirerChangeRequestRemoveHirerRepository } from './hirer-change-request-remove-hirer.repository';
import { JointHirer } from '../../components/joint-hirer/joint-hirer';

export class HirerChangeRequestRemoveHirer
  extends ObjectBase
  implements IHirerChangeRequestRemoveHirerAttr
{
  ObjectId: string;
  ObjectName: string;
  ObjectType: string = 'HirerChangeRequestRemoveHirer';
  TableName: string = 'hirerChangeRequest_RemoveHirer';
  RequestId: string;
  TargetHirerId: string;

  get RemoveHirerId(): string {
    return this.ObjectId;
  }

  set RemoveHirerId(value: string) {
    this.ObjectId = value;
  }

  protected static _Repository = new HirerChangeRequestRemoveHirerRepository();

  protected constructor(attr?: IHirerChangeRequestRemoveHirerAttr) {
    super();
    if (attr) {
      this.RemoveHirerId = attr.RemoveHirerId;
      this.RequestId = attr.RequestId;
      this.TargetHirerId = attr.TargetHirerId;
    }
  }

  public static async init(removeHirerId?: string, dbTransaction?: any) {
    try {
      if (removeHirerId) {
        const hirerChangeReqRemoveHirer =
          await HirerChangeRequestRemoveHirer._Repository.findByPk(
            removeHirerId,
            dbTransaction,
          );
        if (hirerChangeReqRemoveHirer) {
          return new HirerChangeRequestRemoveHirer(
            hirerChangeReqRemoveHirer.get({ plain: true }),
          );
        } else {
          throw new ClassError(
            'HirerChangeRequestRemoveHirer',
            'HirerChangeRequestRemoveHirerErrMsg00',
            'HirerChangeRequestRemoveHirer not found',
          );
        }
      }
      return new HirerChangeRequestRemoveHirer();
    } catch (error) {
      throw error;
    }
  }

  public static async findAll(
    search: {
      RequestId?: string;
    },
    dbTransaction?: any,
  ): Promise<HirerChangeRequestRemoveHirer[]> {
    try {
      const results = await HirerChangeRequestRemoveHirer._Repository.findAll({
        where: {
          ...search,
        },
        transaction: dbTransaction,
      });
      return results.map(
        (result) =>
          new HirerChangeRequestRemoveHirer(result.get({ plain: true })),
      );
    } catch (error) {
      console.error('Error finding all HirerChangeRequestRemoveHirer:', error);
      throw error;
    }
  }

  toJSON(): IHirerChangeRequestRemoveHirerAttr {
    return {
      RemoveHirerId: this.RemoveHirerId,
      RequestId: this.RequestId,
      TargetHirerId: this.TargetHirerId,
    };
  }

  public async create(loginUser: LoginUser, dbTransaction?: any) {
    //This method will create a new Hirer Change Request Remove Hirer.
    try {
      //Make sure targetHirerId and requestId is not empty
      if (!this.TargetHirerId && !this.RequestId) {
        throw new ClassError(
          'HirerChangeRequestRemoveHirer',
          'HirerChangeRequestRemoveHirerErrMsg01',
          'TargetHirerId and RequestId are required',
        );
      }

      //Insert record into the database
      this.ObjectId = this.createId();
      const entityValueAfter = this.toJSON();
      const removeHirer =
        await HirerChangeRequestRemoveHirer._Repository.create(
          entityValueAfter,
          {
            transaction: dbTransaction,
          },
        );

      //Create activity log
      const activity = new Activity();
      activity.ObjectId = this._createId();
      activity.Action = ActionEnum.CREATE;
      activity.Description = `Created new Hirer Change Request Remove Hirer`;
      activity.EntityId = removeHirer.RemoveHirerId;
      activity.EntityType = this.ObjectType;
      activity.EntityValueBefore = JSON.stringify({});
      activity.EntityValueAfter = JSON.stringify(removeHirer);

      await activity.create(loginUser.ObjectId, dbTransaction);
    } catch (error) {
      console.error('Error creating HirerChangeRequestRemoveHirer:', error);
      throw error;
    }
  }
}