const Event = require('../Models/Event');
const User = require('../Models/User');
const EventParticipationLog = require('../Models/EventParticipationLog');
const axios = require('axios');
const logger = require('winston');
const { config } = require('../config/environment');

// ML API configuration
const ML_API_URL = config.ml.apiUrl;
const ML_RECOMMENDATION_ENABLED = config.ml.recommendationEnabled;
const ML_API_TIMEOUT = config.ml.timeout;

/**
 * Get personalized event recommendations for a user
 */
async function getEventRecommendations(req, res) {
  try {
    const userId = req.user.id;
    const { limit = 10, page = 1 } = req.query;

    // Get user profile data
    const user = await User.findById(userId);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    // Get user's event history
    const userHistory = await EventParticipationLog.find({ userId })
      .populate('eventId', 'title description tags type organizer date')
      .sort({ timestamp: -1 })
      .limit(20);

    // Get user's interests and skills
    const userProfile = {
      userId: user._id,
      userName: user.name,
      userEmail: user.email,
      interests: user.interests || [],
      skills: user.skills || [],
      attendedEvents: userHistory
        .filter((log) => log.eventId && log.status === 'attended')
        .map((log) => ({
          eventId: log.eventId._id,
          title: log.eventId.title,
          type: log.eventId.type,
          tags: log.eventId.tags || [],
          organizer: log.eventId.organizer,
        })),
      registeredEvents: userHistory
        .filter((log) => log.eventId && log.status === 'registered')
        .map((log) => ({
          eventId: log.eventId._id,
          title: log.eventId.title,
          type: log.eventId.type,
          tags: log.eventId.tags || [],
          organizer: log.eventId.organizer,
        })),
    };

    // Get available events for recommendation
    const maxCandidates = Math.min(parseInt(limit) * 50, 500);
    const availableEvents = await Event.find({
      verificationStatus: 'approved',
      date: { $gte: new Date() },
    })
      .select('title description tags type organizer schedule hostUserId institutionId date')
      .sort({ date: 1 })
      .limit(maxCandidates);

    // Prepare data for ML API
    const recommendationData = {
      userProfile,
      availableEvents: availableEvents.map((event) => ({
        eventId: event._id,
        title: event.title,
        description: event.description,
        type: event.type,
        tags: event.tags || [],
        organizer: event.organizer,
        date: event.date,
      })),
      limit: parseInt(limit),
      page: parseInt(page),
    };

    // Call ML API for recommendations
    try {
      // Check if ML recommendations are enabled
      if (!ML_RECOMMENDATION_ENABLED) {
        logger.info('ML recommendations disabled, using fallback');
        const fallbackRecommendations = await getFallbackRecommendations(
          userProfile,
          availableEvents,
          limit,
        );

        return res.json({
          recommendations: fallbackRecommendations,
          pagination: {
            page: parseInt(page),
            limit: parseInt(limit),
            total: fallbackRecommendations.length,
          },
          userProfile: {
            interests: userProfile.interests,
            skills: userProfile.skills,
            attendedCount: userProfile.attendedEvents.length,
            registeredCount: userProfile.registeredEvents.length,
          },
          note: 'Using fallback recommendations (ML feature disabled)',
        });
      }

      const mlResponse = await axios.post(
        `${ML_API_URL}/recommend`,
        recommendationData,
        {
          timeout: ML_API_TIMEOUT,
        },
      );

      const recommendations = mlResponse.data.recommendations || [];

      // Get full event details for recommended events
      const recommendedEventIds = recommendations.map((rec) => rec.eventId);
      const recommendedEvents = await Event.find({
        _id: { $in: recommendedEventIds },
      }).populate('hostUserId', 'name email');

      // Map recommendations with full event details
      const finalRecommendations = recommendations
        .map((rec) => {
          if (!rec.eventId) return null;
          const eventIdStr = rec.eventId.toString();
          const event = recommendedEvents.find(
            (e) => e && e._id && e._id.toString() === eventIdStr,
          );
          return {
            eventId: rec.eventId,
            similarityScore: rec.similarityScore,
            reason: rec.reason,
            event: event
              ? {
                _id: event._id,
                title: event.title,
                description: event.description,
                tags: event.tags,
                type: event.type,
                organizer: event.organizer,
                schedule: event.schedule,
                host: event.hostUserId,
                verificationStatus: event.verificationStatus,
                isPaid: event.isPaid,
                price: event.price,
              }
              : null,
          };
        })
        .filter((rec) => rec.event !== null);

      return res.json({
        recommendations: finalRecommendations,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total: finalRecommendations.length,
        },
        userProfile: {
          interests: userProfile.interests,
          skills: userProfile.skills,
          attendedCount: userProfile.attendedEvents.length,
          registeredCount: userProfile.registeredEvents.length,
        },
      });
    } catch (mlError) {
      logger.error('ML API error:', mlError);

      // Fallback: return events based on user interests
      const fallbackRecommendations = await getFallbackRecommendations(
        userProfile,
        availableEvents,
        limit,
      );

      return res.json({
        recommendations: fallbackRecommendations,
        pagination: {
          page: parseInt(page),
          limit: parseInt(limit),
          total: fallbackRecommendations.length,
        },
        userProfile: {
          interests: userProfile.interests,
          skills: userProfile.skills,
          attendedCount: userProfile.attendedEvents.length,
          registeredCount: userProfile.registeredEvents.length,
        },
        note: 'Using fallback recommendations (ML API unavailable)',
      });
    }
  } catch (error) {
    logger.error('Event recommendation error:', error);
    return res
      .status(500)
      .json({ error: 'Error getting event recommendations' });
  }
}

/**
 * Fallback recommendation system based on user interests
 */
async function getFallbackRecommendations(userProfile, availableEvents, limit) {
  const userInterests = userProfile.interests.map((interest) =>
    interest.toLowerCase(),
  );
  const userSkills = userProfile.skills.map((skill) => skill.toLowerCase());

  // Score events based on user interests and skills
  const scoredEvents = availableEvents.map((event) => {
    let score = 0;
    const eventTags = (event.tags || []).map((tag) => tag.toLowerCase());
    const eventType = (event.type || '').toLowerCase();
    const eventDescription = (event.description || '').toLowerCase();

    // Score based on interests
    userInterests.forEach((interest) => {
      if (eventTags.includes(interest)) score += 3;
      if (eventType.includes(interest)) score += 2;
      if (eventDescription.includes(interest)) score += 1;
    });

    // Score based on skills
    userSkills.forEach((skill) => {
      if (eventTags.includes(skill)) score += 2;
      if (eventType.includes(skill)) score += 1;
    });

    // Bonus for events from same organizer as attended events
    const attendedOrganizers = userProfile.attendedEvents.map(
      (e) => e.organizer,
    );
    if (attendedOrganizers.includes(event.organizer)) score += 1;

    return {
      eventId: event._id,
      similarityScore: score,
      reason:
        score > 0 ? 'Based on your interests and skills' : 'Popular events',
      event: {
        _id: event._id,
        title: event.title,
        description: event.description,
        tags: event.tags,
        type: event.type,
        organizer: event.organizer,
        schedule: event.schedule,
      },
    };
  });

  // Sort by score and return top recommendations
  return scoredEvents
    .sort((a, b) => b.similarityScore - a.similarityScore)
    .slice(0, parseInt(limit));
}

/**
 * Get similar events based on a specific event
 */
async function getSimilarEvents(req, res) {
  try {
    const { eventId } = req.params;
    const { limit = 5 } = req.query;

    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found' });
    }

    // Find events with similar tags, type, or organizer
    const similarEvents = await Event.find({
      _id: { $ne: eventId },
      verificationStatus: 'approved',
      date: { $gte: new Date() },
      $or: [
        { tags: { $in: event.tags || [] } },
        { type: event.type },
        { organizer: event.organizer },
      ],
    })
      .populate('hostUserId', 'name email')
      .limit(parseInt(limit))
      .sort({ date: 1 });

    const recommendations = similarEvents.map((similarEvent) => ({
      eventId: similarEvent._id,
      similarityScore: calculateSimilarityScore(event, similarEvent),
      reason: getSimilarityReason(event, similarEvent),
      event: {
        _id: similarEvent._id,
        title: similarEvent.title,
        description: similarEvent.description,
        tags: similarEvent.tags,
        type: similarEvent.type,
        organizer: similarEvent.organizer,
        date: similarEvent.date,
        host: similarEvent.hostUserId,
        verificationStatus: similarEvent.verificationStatus,
        isPaid: similarEvent.isPaid,
        price: similarEvent.price,
      },
    }));

    return res.json({
      baseEvent: {
        _id: event._id,
        title: event.title,
        description: event.description,
        tags: event.tags,
        type: event.type,
        organizer: event.organizer,
      },
      similarEvents: recommendations,
    });
  } catch (error) {
    logger.error('Similar events error:', error);
    return res.status(500).json({ error: 'Error getting similar events' });
  }
}

/**
 * Calculate similarity score between two events
 */
function calculateSimilarityScore(event1, event2) {
  let score = 0;

  // Tag similarity
  const tags1 = new Set(event1.tags || []);
  const tags2 = new Set(event2.tags || []);
  const tagIntersection = new Set([...tags1].filter((x) => tags2.has(x)));
  score += tagIntersection.size * 2;

  // Type similarity
  if (event1.type === event2.type) score += 3;

  // Organizer similarity
  if (event1.organizer === event2.organizer) score += 2;

  return score;
}

/**
 * Get reason for similarity
 */
function getSimilarityReason(event1, event2) {
  const reasons = [];

  if (event1.type === event2.type) {
    reasons.push('Same event type');
  }

  const tags1 = new Set(event1.tags || []);
  const tags2 = new Set(event2.tags || []);
  const commonTags = [...tags1].filter((x) => tags2.has(x));

  if (commonTags.length > 0) {
    reasons.push(`Similar tags: ${commonTags.join(', ')}`);
  }

  if (event1.organizer === event2.organizer) {
    reasons.push('Same organizer');
  }

  return reasons.join(', ');
}

/**
 * Update user preferences based on event interaction
 */
async function updateUserPreferences(req, res) {
  try {
    const userId = req.user.id;
    const { eventId, action } = req.body; // action: 'view', 'like', 'attend', 'register'

    const user = await User.findById(userId);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }

    const event = await Event.findById(eventId);
    if (!event) {
      return res.status(404).json({ error: 'Event not found' });
    }

    // Update user preferences based on action
    const updatedInterests = [...(user.interests || [])];
    const updatedSkills = [...(user.skills || [])];

    if (action === 'like' || action === 'attend') {
      // Add event tags to interests if not already present
      (event.tags || []).forEach((tag) => {
        if (!updatedInterests.includes(tag)) {
          updatedInterests.push(tag);
        }
      });

      // Add event type to interests if not already present
      if (event.type && !updatedInterests.includes(event.type)) {
        updatedInterests.push(event.type);
      }
    }

    // Update user profile
    await User.findByIdAndUpdate(userId, {
      interests: updatedInterests,
      skills: updatedSkills,
    });

    return res.json({
      message: 'User preferences updated successfully',
      updatedInterests,
      updatedSkills,
    });
  } catch (error) {
    logger.error('Update user preferences error:', error);
    return res.status(500).json({ error: 'Error updating user preferences' });
  }
}

module.exports = {
  getEventRecommendations,
  getSimilarEvents,
  updateUserPreferences,
};