SerpentRace/SerpentRace_Backend/src/Repositories/UserRepository.ts

import { Repository, DataSource } from 'typeorm';
import { User } from '../Database/entities/user.entity';
import { UserCreateDto, UserUpdateDto, UserResponseDto, UserBasicDto, UsersListResponseDto } from '../Database/dto/user.dto';
import { UserMapper } from '../Database/mappers/user.mapper';
import { IUserRepository } from './interfaces/IUserRepository';

export class UserRepository implements IUserRepository {
  private repository: Repository<User>;

  constructor(dataSource: DataSource) {
    //  console.log('🗃️ UserRepository constructor called with dataSource:', !!dataSource);
    this.repository = dataSource.getRepository(User);
    // console.log('🗃️ TypeORM Repository initialized:', !!this.repository);
  }

  // Basic CRUD operations
  async create(userCreateDto: UserCreateDto): Promise<UserResponseDto> {
    // console.log('Creating user with DTO:', userCreateDto);
    const user = UserMapper.toEntity(userCreateDto);
    // console.log('Creating user with DTO:', user);
    const savedUser = await this.repository.save(user);
    // console.log('User created:', savedUser);
    return UserMapper.toResponseDto(savedUser);
  }

  async findById(id: number): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({ where: { id } });
    return user ? UserMapper.toResponseDto(user) : null;
  }

  async findByUsername(username: string): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({ where: { username } });
    return user ? UserMapper.toResponseDto(user) : null;
  }

  async findByEmail(email: string): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({ where: { email } });
    return user ? UserMapper.toResponseDto(user) : null;
  }

  async findAll(): Promise<UsersListResponseDto> {
    const users = await this.repository.find();
    const userDtos = users.map(user => UserMapper.toResponseDto(user));
    return new UsersListResponseDto(userDtos);
  }

  async update(id: number, userUpdateDto: UserUpdateDto): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({ where: { id } });
    if (!user) return null;
    
    const updatedUser = UserMapper.updateEntity(user, userUpdateDto);
    const savedUser = await this.repository.save(updatedUser);
    return UserMapper.toResponseDto(savedUser);
  }

  async deleteById(id: number): Promise<boolean> {
    const result = await this.repository.delete(id);
    return result.affected !== 0;
  }

  async exists(id: number): Promise<boolean> {
    const count = await this.repository.count({ where: { id } });
    return count > 0;
  }

  async usernameExists(username: string): Promise<boolean> {
    const count = await this.repository.count({ where: { username } });
    return count > 0;
  }

  async emailExists(email: string): Promise<boolean> {
    const count = await this.repository.count({ where: { email } });
    return count > 0;
  }

  // Company related queries
  // async findByCompanyId(companyId: number): Promise<UsersListResponseDto> {
  //   const users = await this.repository.find({ where: { CompanyId: companyId } });
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // async findByCompanyToken(companyToken: string): Promise<UsersListResponseDto> {
  //   const users = await this.repository.find({ where: { CompanyToken: companyToken } });
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // Search and filtering
  // async findByPartialUsername(partialUsername: string): Promise<UsersListResponseDto> {
  //   const users = await this.repository
  //     .createQueryBuilder('user')
  //     .where('user.username LIKE :username', { username: `%${partialUsername}%` })
  //     .getMany();
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // async findByPartialName(partialName: string): Promise<UsersListResponseDto> {
  //   const users = await this.repository
  //     .createQueryBuilder('user')
  //     .where('user.FirstName LIKE :name', { name: `%${partialName}%` })
  //     .orWhere('user.LastName LIKE :name', { name: `%${partialName}%` })
  //     .getMany();
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // Pagination
  // async findWithPagination(skip: number, take: number): Promise<{ users: UsersListResponseDto, total: number }> {
  //   const [users, total] = await this.repository.findAndCount({
  //     skip,
  //     take,
  //     order: { RegDate: 'DESC' }
  //   });
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return {
  //     users: new UsersListResponseDto(userDtos),
  //     total
  //   };
  // }

  // Basic info
  // async findBasicById(id: number): Promise<UserBasicDto | null> {
  //   const user = await this.repository.findOne({ where: { id } });
  //   return user ? UserMapper.toBasicDto(user) : null;
  // }

  async findAllBasic(): Promise<UserBasicDto[]> {
    const users = await this.repository.find();
    return users.map(user => UserMapper.toBasicDto(user));
  }

  // Relations
  async findWithCompany(id: number): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({
      where: { id },
      relations: ['company']
    });
    return user ? UserMapper.toResponseDto(user) : null;
  }

  async findWithQuestionBanks(id: number): Promise<UserResponseDto | null> {
    const user = await this.repository.findOne({
      where: { id },
      relations: ['questionBanks']
    });
    return user ? UserMapper.toResponseDto(user) : null;
  }

  // async findWithAllRelations(id: number): Promise<UserResponseDto | null> {
  //   const user = await this.repository.findOne({
  //     where: { id },
  //     relations: ['company', 'questionBanks']
  //   });
  //   return user ? UserMapper.toResponseDto(user) : null;
  // }

  // Counting
  // async count(): Promise<number> {
  //   return await this.repository.count();
  // }

  // async countByCompany(companyId: number): Promise<number> {
  //   return await this.repository.count({ where: { CompanyId: companyId } });
  // }

  // Date range queries
  // async findByDateRange(startDate: Date, endDate: Date): Promise<UsersListResponseDto> {
  //   const users = await this.repository
  //     .createQueryBuilder('user')
  //     .where('user.RegDate >= :startDate', { startDate })
  //     .andWhere('user.RegDate <= :endDate', { endDate })
  //     .getMany();
  //   const userDtos = users.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // Bulk operations
  // async createMany(userCreateDtos: UserCreateDto[]): Promise<UsersListResponseDto> {
  //   const users = userCreateDtos.map(dto => UserMapper.toEntity(dto));
  //   const savedUsers = await this.repository.save(users);
  //   const userDtos = savedUsers.map(user => UserMapper.toResponseDto(user));
  //   return new UsersListResponseDto(userDtos);
  // }

  // async deleteByIds(ids: number[]): Promise<boolean> {
  //   const result = await this.repository.delete(ids);
  //   return result.affected !== 0;
  // }

  // Authentication support (returns raw entity for password verification)
  async findRawByUsername(username: string): Promise<User | null> {
    console
    return await this.repository.findOne({ where: { username } });
  }

  // async findRawById(id: number): Promise<User | null> {
  //   return await this.repository.findOne({ where: { id } });
  // }

  async findRawByEmail(email: string): Promise<User | null> {
    return await this.repository.findOne({ where: { email } });
  }
}