Tasks/backend/models/GuestSession.js

const { v4: uuidv4 } = require('uuid');
const jwt = require('jsonwebtoken');
const config = require('../config/config');

module.exports = (sequelize, DataTypes) => {
  const GuestSession = sequelize.define('GuestSession', {
    id: {
      type: DataTypes.CHAR(36),
      primaryKey: true,
      defaultValue: () => uuidv4(),
      allowNull: false,
      comment: 'UUID primary key'
    },
    guestId: {
      type: DataTypes.STRING(100),
      allowNull: false,
      unique: {
        msg: 'Guest ID already exists'
      },
      field: 'guest_id',
      validate: {
        notEmpty: {
          msg: 'Guest ID cannot be empty'
        }
      },
      comment: 'Unique guest identifier'
    },
    sessionToken: {
      type: DataTypes.STRING(500),
      allowNull: false,
      unique: {
        msg: 'Session token already exists'
      },
      field: 'session_token',
      comment: 'JWT session token'
    },
    deviceId: {
      type: DataTypes.STRING(255),
      allowNull: true,
      field: 'device_id',
      comment: 'Device identifier (optional)'
    },
    ipAddress: {
      type: DataTypes.STRING(45),
      allowNull: true,
      field: 'ip_address',
      comment: 'IP address (supports IPv6)'
    },
    userAgent: {
      type: DataTypes.TEXT,
      allowNull: true,
      field: 'user_agent',
      comment: 'Browser user agent string'
    },
    quizzesAttempted: {
      type: DataTypes.INTEGER,
      allowNull: false,
      defaultValue: 0,
      field: 'quizzes_attempted',
      validate: {
        min: 0
      },
      comment: 'Number of quizzes attempted by guest'
    },
    maxQuizzes: {
      type: DataTypes.INTEGER,
      allowNull: false,
      defaultValue: 3,
      field: 'max_quizzes',
      validate: {
        min: 1,
        max: 100
      },
      comment: 'Maximum quizzes allowed for this guest'
    },
    expiresAt: {
      type: DataTypes.DATE,
      allowNull: false,
      field: 'expires_at',
      validate: {
        isDate: true,
        isAfter: new Date().toISOString()
      },
      comment: 'Session expiration timestamp'
    },
    isConverted: {
      type: DataTypes.BOOLEAN,
      allowNull: false,
      defaultValue: false,
      field: 'is_converted',
      comment: 'Whether guest converted to registered user'
    },
    convertedUserId: {
      type: DataTypes.CHAR(36),
      allowNull: true,
      field: 'converted_user_id',
      comment: 'User ID if guest converted to registered user'
    }
  }, {
    sequelize,
    modelName: 'GuestSession',
    tableName: 'guest_sessions',
    timestamps: true,
    underscored: true,
    indexes: [
      {
        unique: true,
        fields: ['guest_id']
      },
      {
        unique: true,
        fields: ['session_token']
      },
      {
        fields: ['expires_at']
      },
      {
        fields: ['is_converted']
      },
      {
        fields: ['converted_user_id']
      },
      {
        fields: ['device_id']
      },
      {
        fields: ['created_at']
      }
    ]
  });

  // Static method to generate guest ID
  GuestSession.generateGuestId = function() {
    const timestamp = Date.now();
    const randomStr = Math.random().toString(36).substring(2, 15);
    return `guest_${timestamp}_${randomStr}`;
  };

  // Static method to generate session token (JWT)
  GuestSession.generateToken = function(guestId, sessionId) {
    const payload = {
      guestId,
      sessionId,
      type: 'guest'
    };

    return jwt.sign(payload, config.jwt.secret, {
      expiresIn: config.guest.sessionExpireHours + 'h'
    });
  };

  // Static method to verify and decode token
  GuestSession.verifyToken = function(token) {
    try {
      return jwt.verify(token, config.jwt.secret);
    } catch (error) {
      throw new Error('Invalid or expired token');
    }
  };

  // Static method to create new guest session
  GuestSession.createSession = async function(options = {}) {
    const guestId = GuestSession.generateGuestId();
    const sessionId = uuidv4();
    const sessionToken = GuestSession.generateToken(guestId, sessionId);
    
    const expiryHours = options.expiryHours || config.guest.sessionExpireHours || 24;
    const expiresAt = new Date(Date.now() + expiryHours * 60 * 60 * 1000);

    const session = await GuestSession.create({
      id: sessionId,
      guestId,
      sessionToken,
      deviceId: options.deviceId || null,
      ipAddress: options.ipAddress || null,
      userAgent: options.userAgent || null,
      maxQuizzes: options.maxQuizzes || config.guest.maxQuizzes || 3,
      expiresAt
    });

    return session;
  };

  // Instance methods
  GuestSession.prototype.isExpired = function() {
    return new Date() > new Date(this.expiresAt);
  };

  GuestSession.prototype.hasReachedQuizLimit = function() {
    return this.quizzesAttempted >= this.maxQuizzes;
  };

  GuestSession.prototype.getRemainingQuizzes = function() {
    return Math.max(0, this.maxQuizzes - this.quizzesAttempted);
  };

  GuestSession.prototype.incrementQuizAttempt = async function() {
    this.quizzesAttempted += 1;
    await this.save();
  };

  GuestSession.prototype.extend = async function(hours = 24) {
    const newExpiry = new Date(Date.now() + hours * 60 * 60 * 1000);
    this.expiresAt = newExpiry;
    
    // Regenerate token with new expiry
    this.sessionToken = GuestSession.generateToken(this.guestId, this.id);
    await this.save();
    
    return this;
  };

  GuestSession.prototype.convertToUser = async function(userId) {
    this.isConverted = true;
    this.convertedUserId = userId;
    await this.save();
  };

  GuestSession.prototype.getSessionInfo = function() {
    return {
      guestId: this.guestId,
      sessionId: this.id,
      quizzesAttempted: this.quizzesAttempted,
      maxQuizzes: this.maxQuizzes,
      remainingQuizzes: this.getRemainingQuizzes(),
      expiresAt: this.expiresAt,
      isExpired: this.isExpired(),
      hasReachedLimit: this.hasReachedQuizLimit(),
      isConverted: this.isConverted
    };
  };

  // Class methods
  GuestSession.findByGuestId = async function(guestId) {
    return await this.findOne({
      where: { guestId }
    });
  };

  GuestSession.findByToken = async function(token) {
    try {
      const decoded = GuestSession.verifyToken(token);
      return await this.findOne({
        where: {
          guestId: decoded.guestId,
          id: decoded.sessionId
        }
      });
    } catch (error) {
      return null;
    }
  };

  GuestSession.findActiveSession = async function(guestId) {
    return await this.findOne({
      where: {
        guestId,
        isConverted: false
      }
    });
  };

  GuestSession.cleanupExpiredSessions = async function() {
    const expiredCount = await this.destroy({
      where: {
        expiresAt: {
          [sequelize.Sequelize.Op.lt]: new Date()
        },
        isConverted: false
      }
    });
    return expiredCount;
  };

  GuestSession.getActiveGuestCount = async function() {
    return await this.count({
      where: {
        expiresAt: {
          [sequelize.Sequelize.Op.gt]: new Date()
        },
        isConverted: false
      }
    });
  };

  GuestSession.getConversionRate = async function() {
    const total = await this.count();
    if (total === 0) return 0;

    const converted = await this.count({
      where: { isConverted: true }
    });

    return Math.round((converted / total) * 100);
  };

  // Hooks
  GuestSession.beforeValidate((session) => {
    // Ensure UUID is set
    if (!session.id) {
      session.id = uuidv4();
    }

    // Ensure expiry is in the future (only for new records, not updates)
    if (session.isNewRecord && session.expiresAt && new Date(session.expiresAt) <= new Date()) {
      throw new Error('Expiry date must be in the future');
    }
  });

  // Define associations
  GuestSession.associate = function(models) {
    // GuestSession belongs to a User (if converted)
    if (models.User) {
      GuestSession.belongsTo(models.User, {
        foreignKey: 'convertedUserId',
        as: 'convertedUser'
      });
    }

    // GuestSession has many quiz sessions
    if (models.QuizSession) {
      GuestSession.hasMany(models.QuizSession, {
        foreignKey: 'guestSessionId',
        as: 'quizSessions'
      });
    }
  };

  return GuestSession;
};