const db = require('../config/database');

// Create feedback from app user to hospital
exports.createAppUserFeedback = async (req, res) => {
    try {
      const {
        hospital_code,
        rating,
        purpose,
        information_received,
        feedback_text,
        improvement,
      } = req.body;
      const user_id = req.user.id; // From auth middleware
  
      console.log(
        'user data---',
        hospital_code,
        rating,
        purpose,
        information_received,
        feedback_text,
        improvement
      );
  
      // Validate required fields
      if (!hospital_code) {
        return res.status(400).json({
          error: 'Hospital code is required',
        });
      }
  
      // Set default values if not provided
      const validRating = ['Terrible', 'Bad', 'Okay', 'Good', 'Awesome'];
      const validInfoReceived = ['Yes', 'Partially', 'No'];
  
      const finalRating =
        rating && validRating.includes(rating) ? rating : null;
      const finalInfoReceived =
        information_received && validInfoReceived.includes(information_received)
          ? information_received
          : null;
  
      // Check if hospital exists
      const hospitalCheck = await db.query(
        'SELECT id FROM hospitals WHERE hospital_code = ?',
        [hospital_code]
      );
  
      if (hospitalCheck.length === 0) {
        return res.status(404).json({
          error: 'Hospital not found',
        });
      }
  
      // Insert feedback
      const query = `
        INSERT INTO feedback (
          sender_type,
          sender_id,
          receiver_type,
          receiver_id,
          rating,
          purpose,
          information_received,
          feedback_text,
          improvement
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
      `;
  
      const result = await db.query(query, [
        'appuser',
        user_id,
        'hospital',
        hospitalCheck[0].id,
        finalRating,
        purpose,
        finalInfoReceived,
        feedback_text || null,
        improvement || null,
      ]);
  
      res.status(201).json({
        message: 'Feedback submitted successfully',
        feedback_id: result.insertId,
      });
    } catch (error) {
      console.error('Error creating app user feedback:', error);
      res.status(500).json({ error: 'Internal server error' });
    }
};
  
// Create feedback from hospital to Spurrin
exports.createHospitalFeedback = async (req, res) => {
    try {
        const { 
            rating, 
            purpose, 
            information_received, 
            feedback_text, 
            improvement 
        } = req.body;
        const hospital_code = req.user.hospital_code; // From auth middleware

        // Validate required fields
        if (!rating || !purpose || !information_received) {
            return res.status(400).json({
                error: "Rating, purpose and information received are required"
            });
        }

        // Validate rating enum
        const validRating = ['angry', 'sad', 'neutral', 'happy', 'awesome'];
        if (!validRating.includes(rating)) {
            return res.status(400).json({
                error: "Invalid rating value"
            });
        }

        // Validate information_received enum
        const validInfoReceived = ['Yes', 'Partially', 'No'];
        if (!validInfoReceived.includes(information_received)) {
            return res.status(400).json({
                error: "Invalid information received value"
            });
        }

        // Get hospital ID
        const hospitalCheck = await db.query(
            'SELECT id FROM hospitals WHERE hospital_code = ?',
            [hospital_code]
        );

        if (hospitalCheck.length === 0) {
            return res.status(404).json({
                error: "Hospital not found"
            });
        }

        // Insert feedback
        const query = `
            INSERT INTO feedback (
                sender_type,
                sender_id,
                receiver_type,
                receiver_id,
                rating,
                purpose,
                information_received,
                feedback_text,
                improvement
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        `;

        const result = await db.query(query, [
            'hospital',
            hospitalCheck[0].id,
            'spurrin',
            1, // Assuming 1 is the ID for Spurrin
            rating,
            purpose,
            information_received,
            feedback_text || null,
            improvement || null
        ]);

        res.status(201).json({
            message: "Feedback submitted successfully",
            feedback_id: result.insertId
        });

    } catch (error) {
        console.error("Error creating hospital feedback:", error);
        res.status(500).json({ error: "Internal server error" });
    }
};

// Get feedbacks for a hospital (for hospital users)
exports.getHospitalFeedbacks = async (req, res) => {
    try {
        const hospital_code = req.user.hospital_code; // From auth middleware

        // Get hospital ID
        const hospitalCheck = await db.query(
            'SELECT id FROM hospitals WHERE hospital_code = ?',
            [hospital_code]
        );

        if (hospitalCheck.length === 0) {
            return res.status(404).json({
                error: "Hospital not found"
            });
        }

        const query = `
            SELECT 
                f.feedback_id,
                f.sender_type,
                f.sender_id,
                f.receiver_type,
                f.receiver_id,
                f.rating,
                f.purpose,
                f.information_received,
                f.feedback_text,
                f.improvement,
                f.created_at,
                f.is_forwarded,
                au.username as user_name,
                au.email as user_email
            FROM feedback f
            LEFT JOIN app_users au ON f.sender_id = au.id AND f.sender_type = 'appuser'
            WHERE f.receiver_type = 'hospital' AND f.receiver_id = ?
            ORDER BY f.created_at DESC
        `;

        const feedbacks = await db.query(query, [hospitalCheck[0].id]);

        res.status(200).json({
            message: "Feedbacks fetched successfully",
            data: feedbacks
        });

    } catch (error) {
        console.error("Error fetching hospital feedbacks:", error);
        res.status(500).json({ error: "Internal server error" });
    }
};

// Get all feedbacks (for Spurrin admin)
exports.getAllFeedbacks = async (req, res) => {
    try {
        // Check authorization
        if(req.user.role !== 'Spurrinadmin' && req.user.role !== 6){
            return res.status(403).json({
                error: "You are not authorized!"
            });
        }

        const query = `
            SELECT 
                f.feedback_id,
                f.sender_type,
                f.sender_id,
                f.receiver_type,
                f.receiver_id,
                f.rating,
                f.purpose,
                f.information_received,
                f.feedback_text,
                f.created_at,
                f.is_forwarded,
                au.name as user_name,
                au.email as user_email,
                h.name_hospital as hospital_name,
                h.hospital_code
            FROM feedback f
            LEFT JOIN app_users au ON f.sender_id = au.id AND f.sender_type = 'appuser'
            LEFT JOIN hospitals h ON f.sender_id = h.id AND f.sender_type = 'hospital'
            ORDER BY f.created_at DESC
        `;

        const feedbacks = await db.query(query);

        res.status(200).json({
            message: "All feedbacks fetched successfully",
            data: feedbacks
        });

    } catch (error) {
        console.error("Error fetching all feedbacks:", error);
        res.status(500).json({ error: "Internal server error" });
    }
};

// Forward app user feedbacks to Spurrin (for hospital users)
exports.forwardAppUserFeedbacks = async (req, res) => {
    try {
        const { feedback_ids } = req.body;
        const hospital_code = req.user.hospital_code;

        if (!feedback_ids || !Array.isArray(feedback_ids) || feedback_ids.length === 0) {
            return res.status(400).json({ error: "Feedback IDs array is required" });
        }

        const hospitalCheck = await db.query(
            'SELECT id FROM hospitals WHERE hospital_code = ?',
            [hospital_code]
        );

        if (hospitalCheck.length === 0) {
            return res.status(404).json({ error: "Hospital not found" });
        }

        const hospitalId = hospitalCheck[0].id;

        const verifyQuery = `
            SELECT feedback_id 
            FROM feedback 
            WHERE feedback_id IN (?) 
            AND receiver_type = 'hospital' 
            AND receiver_id = ? 
            AND sender_type = 'appuser'
        `;
        
        const validFeedbacks = await db.query(verifyQuery, [feedback_ids, hospitalId]);

        if (validFeedbacks.length !== feedback_ids.length) {
            return res.status(400).json({
                error: "One or more feedback IDs are invalid or don't belong to this hospital"
            });
        }

        const forwardPromises = feedback_ids.map(async (feedback_id) => {
            const originalFeedback = await db.query(
                'SELECT * FROM feedback WHERE feedback_id = ?',
                [feedback_id]
            );

            if (originalFeedback.length === 0) return null;
            const feedback = originalFeedback[0];

            // Insert new feedback for Spurrin
            await db.query(`
                INSERT INTO feedback (
                    sender_type,
                    sender_id,
                    receiver_type,
                    receiver_id,
                    rating,
                    purpose,
                    information_received,
                    feedback_text,
                    improvement
                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
                [
                    'hospital',
                    hospitalId,
                    'spurrin',
                    1, // Spurrin ID
                    feedback.rating,
                    `Purpose: ${feedback.purpose}`,
                    feedback.information_received,
                    feedback.feedback_text,
                    feedback.improvement || null
                ]
            );

            // Mark original feedback as forwarded
            await db.query(
                'UPDATE feedback SET is_forwarded = 1 WHERE feedback_id = ?',
                [feedback_id]
            );
        });

        await Promise.all(forwardPromises);

        res.status(200).json({
            message: "Feedbacks forwarded to Spurrin successfully",
            forwarded_count: feedback_ids.length
        });

    } catch (error) {
        console.error("Error forwarding feedbacks:", error);
        res.status(500).json({ error: "Internal server error" });
    }
};

// API to get all forwarded feedbacks for Spurrin
exports.getForwardedFeedbacks = async (req, res) => {
    try {
        // Check authorization
        if (req.user.role !== 'Spurrinadmin' && req.user.role !== 6) {
            return res.status(403).json({
                error: "You are not authorized!"
            });
        }

        const query = `
            SELECT 
                f.sender_type,
                f.sender_id,
                f.receiver_type,
                f.receiver_id,
                f.rating,
                f.purpose,
                f.information_received,
                f.feedback_text,
                f.created_at,
                f.is_forwarded,
                f.improvement,
                h.name_hospital as sender_hospital,
                h.hospital_code
            FROM feedback f
            LEFT JOIN hospitals h ON f.sender_id = h.id AND f.sender_type = 'hospital'
            WHERE f.receiver_type = 'spurrin'
            ORDER BY f.created_at DESC
        `;

        const forwardedFeedbacks = await db.query(query);

        res.status(200).json({
            message: "Forwarded feedbacks fetched successfully.",
            data: forwardedFeedbacks
        });

    } catch (error) {
        console.error("Error fetching forwarded feedbacks:", error);
        res.status(500).json({ error: "Internal server error" });
    }
};

exports.deleteAppUserFeedback = async (req, res) => {
  try {
    const feedbackId = req.params.id;
    const user = req.user; // From auth middleware

    // Validate that the feedback ID is provided
    if (!feedbackId) {
      return res.status(400).json({
        error: 'Feedback ID is required',
      });
    }

    if (
        user.role !== 'Spurrinadmin' &&
        user.role !== 6 &&
        user.role !== 'Superadmin' &&
        user.role !== 7
        ) {
        return res.status(403).json({
            error: 'You are not authorized!',
        });
    }

    // Delete the feedback
    await db.query('DELETE FROM feedback WHERE feedback_id = ?', [feedbackId]);

    res.status(200).json({
      message: 'Feedback deleted successfully',
    });
  } catch (error) {
    console.error('Error deleting app user feedback:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};