import {
  Column,
  DeleteDateColumn,
  Entity,
  ManyToOne,
  OneToMany,
  Unique,
} from 'typeorm';
import {
  UserDto,
  UserNotificationDto,
  UserOtpDto,
  UserRoleDto,
  UserSpaceDto,
} from '../dtos';
import { AbstractEntity } from '../../abstract/entities/abstract.entity';
import {
  DeviceEntity,
  DeviceNotificationEntity,
  DeviceUserPermissionEntity,
} from '../../device/entities';
import { defaultProfilePicture } from '@app/common/constants/default.profile.picture';
import { RegionEntity } from '../../region/entities';
import { TimeZoneEntity } from '../../timezone/entities';
import { OtpType } from '../../../../src/constants/otp-type.enum';
import { RoleTypeEntity } from '../../role-type/entities';
import { SpaceEntity } from '../../space/entities';
import { VisitorPasswordEntity } from '../../visitor-password/entities';

@Entity({ name: 'user' })
export class UserEntity extends AbstractEntity<UserDto> {
  @Column({
    type: 'uuid',
    default: () => 'gen_random_uuid()', // Use gen_random_uuid() for default value
    nullable: false,
  })
  public uuid: string;

  @Column({
    nullable: true,
    type: 'text',
    default: defaultProfilePicture,
  })
  public profilePicture: string;

  @Column({
    nullable: false,
    unique: true,
  })
  email: string;

  @Column({
    nullable: false,
  })
  public password: string;

  @Column()
  public firstName: string;

  @Column({
    nullable: false,
  })
  public lastName: string;

  @Column({
    nullable: true,
  })
  public refreshToken: string;

  @Column({
    nullable: true,
    default: false,
  })
  public isUserVerified: boolean;

  @Column({
    nullable: false,
    default: true,
  })
  public isActive: boolean;

  @OneToMany(() => UserSpaceEntity, (userSpace) => userSpace.user)
  userSpaces: UserSpaceEntity[];

  @OneToMany(() => DeviceEntity, (userDevice) => userDevice.user)
  userDevice: DeviceEntity[];

  @OneToMany(
    () => UserNotificationEntity,
    (userNotification) => userNotification.user,
  )
  userNotification: UserNotificationEntity[];
  @OneToMany(
    () => DeviceUserPermissionEntity,
    (userPermission) => userPermission.user,
  )
  userPermission: DeviceUserPermissionEntity[];
  @OneToMany(
    () => DeviceNotificationEntity,
    (deviceUserNotification) => deviceUserNotification.user,
  )
  deviceUserNotification: DeviceNotificationEntity[];
  @OneToMany(() => UserRoleEntity, (role) => role.user, {
    nullable: true,
  })
  roles: UserRoleEntity[];
  @ManyToOne(() => RegionEntity, (region) => region.users, { nullable: true })
  region: RegionEntity;
  @ManyToOne(() => TimeZoneEntity, (timezone) => timezone.users, {
    nullable: true,
  })
  timezone: TimeZoneEntity;
  @OneToMany(
    () => VisitorPasswordEntity,
    (visitorPassword) => visitorPassword.user,
  )
  public visitorPasswords: VisitorPasswordEntity[];
  constructor(partial: Partial<UserEntity>) {
    super();
    Object.assign(this, partial);
  }
}

@Entity({ name: 'user-notification' })
@Unique(['user', 'subscriptionUuid'])
export class UserNotificationEntity extends AbstractEntity<UserNotificationDto> {
  @ManyToOne(() => UserEntity, (user) => user.roles, {
    nullable: false,
  })
  user: UserEntity;
  @Column({
    nullable: false,
  })
  subscriptionUuid: string;

  @Column({
    nullable: false,
    default: true,
  })
  active: boolean;
  constructor(partial: Partial<UserNotificationEntity>) {
    super();
    Object.assign(this, partial);
  }
}

@Entity({ name: 'user-otp' })
export class UserOtpEntity extends AbstractEntity<UserOtpDto> {
  @Column({
    type: 'uuid',
    default: () => 'gen_random_uuid()',
    nullable: false,
  })
  public uuid: string;

  @Column({ nullable: false })
  email: string;

  @Column({ nullable: false })
  otpCode: string;

  @Column({ nullable: false })
  expiryTime: Date;

  @Column({
    type: 'enum',
    enum: Object.values(OtpType),
  })
  type: OtpType;

  @DeleteDateColumn({ nullable: true })
  deletedAt?: Date;

  constructor(partial: Partial<UserOtpEntity>) {
    super();
    Object.assign(this, partial);
  }
}

@Entity({ name: 'user-role' })
@Unique(['user', 'roleType'])
export class UserRoleEntity extends AbstractEntity<UserRoleDto> {
  @ManyToOne(() => UserEntity, (user) => user.roles, {
    nullable: false,
  })
  user: UserEntity;

  @ManyToOne(() => RoleTypeEntity, (roleType) => roleType.roles, {
    nullable: false,
  })
  roleType: RoleTypeEntity;

  constructor(partial: Partial<UserRoleEntity>) {
    super();
    Object.assign(this, partial);
  }
}

@Entity({ name: 'user-space' })
@Unique(['user', 'space'])
export class UserSpaceEntity extends AbstractEntity<UserSpaceDto> {
  @Column({
    type: 'uuid',
    default: () => 'gen_random_uuid()', // Use gen_random_uuid() for default value
    nullable: false,
  })
  public uuid: string;

  @ManyToOne(() => UserEntity, (user) => user.userSpaces, { nullable: false })
  user: UserEntity;

  @ManyToOne(() => SpaceEntity, (space) => space.userSpaces, {
    nullable: false,
  })
  space: SpaceEntity;

  constructor(partial: Partial<UserSpaceEntity>) {
    super();
    Object.assign(this, partial);
  }
}