CentralBackend/repositories/user/personal/PersonalUserRepository.js

const db = require('../../../database/database');
const PersonalUser = require('../../../models/PersonalUser');
const User = require('../../../models/User');
const { logger } = require('../../../middleware/logger');

class PersonalUserRepository {
  constructor(unitOfWork) {
    this.unitOfWork = unitOfWork;
  }

  async create({ email, password, firstName, lastName, phone, referralEmail }) {
    logger.info('PersonalUserRepository.create:start', { email, firstName, lastName });
    try {
      console.log('📊 PersonalUserRepository: Creating personal user in database...');
      const hashedPassword = await User.hashPassword(password);

      const conn = this.unitOfWork.connection;
      // 1. Insert into users table
      const userQuery = `
        INSERT INTO users (email, password, user_type, role)
        VALUES (?, ?, 'personal', 'user')
      `;
      const [userResult] = await conn.query(userQuery, [email, hashedPassword]);
      const userId = userResult.insertId;

      logger.info('PersonalUserRepository.create:user_created', { userId });
      console.log('✅ User record created with ID:', userId);

      // 2. Insert into personal_profiles table
      const profileQuery = `
        INSERT INTO personal_profiles (user_id, first_name, last_name, phone)
        VALUES (?, ?, ?, ?)
      `;
      await conn.query(profileQuery, [userId, firstName, lastName, phone]);

      logger.info('PersonalUserRepository.create:profile_created', { userId });
      console.log('✅ Personal profile created');

      logger.info('PersonalUserRepository.create:success', { userId });
      return new PersonalUser(
        userId,
        email,
        hashedPassword,
        firstName,
        lastName,
        phone,
        null,
        referralEmail,
        new Date()
      );
    } catch (error) {
      logger.error('PersonalUserRepository.create:error', { email, error: error.message });
      throw error;
    }
  }

  async findByEmail(email) {
    logger.info('PersonalUserRepository.findByEmail:start', { email });
    try {
      console.log('🔍 PersonalUserRepository: Querying database for personal user...');
      const conn = this.unitOfWork.connection;
      const query = `
        SELECT u.*, pp.first_name, pp.last_name, pp.phone, pp.date_of_birth
        FROM users u
        LEFT JOIN personal_profiles pp ON u.id = pp.user_id
        WHERE u.email = ? AND u.user_type = 'personal'
      `;
      const [rows] = await conn.query(query, [email]);
      if (rows.length > 0) {
        logger.info('PersonalUserRepository.findByEmail:found', { email, userId: rows[0].id });
        const row = rows[0];
        return new PersonalUser(
          row.id,
          row.email,
          row.password,
          row.first_name,
          row.last_name,
          row.phone,
          row.date_of_birth,
          null,
          row.created_at,
          row.updated_at
        );
      }
      logger.info('PersonalUserRepository.findByEmail:not_found', { email });
      return null;
    } catch (error) {
      logger.error('PersonalUserRepository.findByEmail:error', { email, error: error.message });
      throw error;
    }
  }

  async updateProfileAndMarkCompleted(userId, profileData) {
    logger.info('PersonalUserRepository.updateProfileAndMarkCompleted:start', { userId });
    try {
      const conn = this.unitOfWork.connection;
      const {
        dateOfBirth,
        nationality,
        address,
        zip_code,
        city, // Added city
        country,
        phoneSecondary,
        emergencyContactName,
        emergencyContactPhone,
        accountHolderName,
        iban // Added field
      } = profileData;

      await conn.query(
        `UPDATE personal_profiles SET
          date_of_birth = ?, nationality = ?, address = ?, zip_code = ?, city = ?, country = ?, 
          phone_secondary = ?, emergency_contact_name = ?, emergency_contact_phone = ?, 
          account_holder_name = ?
        WHERE user_id = ?`,
        [
          dateOfBirth,
          nationality,
          address,
          zip_code,
          city, // Added city
          country,
          phoneSecondary,
          emergencyContactName,
          emergencyContactPhone,
          accountHolderName,
          userId
        ]
      );

      logger.info('PersonalUserRepository.updateProfileAndMarkCompleted:profile_updated', { userId });

      // Update IBAN in users table if provided
      if (iban) {
        await conn.query(
          `UPDATE users SET iban = ? WHERE id = ?`,
          [iban, userId]
        );
        logger.info('PersonalUserRepository.updateProfileAndMarkCompleted:iban_updated', { userId });
      }

      await conn.query(
        `UPDATE user_status SET profile_completed = 1, profile_completed_at = NOW() WHERE user_id = ?`,
        [userId]
      );
      logger.info('PersonalUserRepository.updateProfileAndMarkCompleted:profile_completed', { userId });
    } catch (error) {
      logger.error('PersonalUserRepository.updateProfileAndMarkCompleted:error', { userId, error: error.message });
      throw error;
    }
  }

  async findById(userId) {
    logger.info('PersonalUserRepository.findById:start', { userId });
    try {
      const conn = this.unitOfWork.connection;
      const query = `
        SELECT u.*, pp.first_name, pp.last_name, pp.phone, pp.date_of_birth
        FROM users u
        LEFT JOIN personal_profiles pp ON u.id = pp.user_id
        WHERE u.id = ? AND u.user_type = 'personal'
      `;
      const [rows] = await conn.query(query, [userId]);
      if (rows.length > 0) {
        logger.info('PersonalUserRepository.findById:found', { userId });
        const row = rows[0];
        return new PersonalUser(
          row.id,
          row.email,
          row.password,
          row.first_name,
          row.last_name,
          row.phone,
          row.date_of_birth,
          null,
          row.created_at,
          row.updated_at
        );
      }
      logger.info('PersonalUserRepository.findById:not_found', { userId });
      return null;
    } catch (error) {
      logger.error('PersonalUserRepository.findById:error', { userId, error: error.message });
      throw error;
    }
  }
}

module.exports = PersonalUserRepository;