using instavibe.Models;
using System.Web.Mvc;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.SqlClient;
using InstaVibe.Models;
using System.Linq;
using System.Web.Razor.Tokenizer;


namespace InstaVibe.Controllers
{
    public class FriendRequestController : Controller
    {
        private string connectionString = ConfigurationManager.ConnectionStrings["InstaVibe"].ConnectionString;

        // Check for new requests 
        public ActionResult Index()
        {
            int currentUserId = Convert.ToInt32(Session["UserId"]);
            var requests = DatabaseHelper.GetPendingRequests(currentUserId);
            return PartialView("_FriendRequestPopup", requests);
        }
        [HttpPost]
        public JsonResult SendRequest(int toUserId)
        {
            int fromUserId = Convert.ToInt32(Session["UserId"]);

            if (fromUserId == toUserId)
            {
                return Json(new { success = false, message = "You can't send a request to yourself." });
            }

            using (SqlConnection con = new SqlConnection(connectionString))
            {
                con.Open();

                // Already following check 
                string checkExist = @"SELECT COUNT(*) FROM followers 
                              WHERE follower_user_id = @FromUserId AND following_user_id = @ToUserId";

                using (SqlCommand cmdCheck = new SqlCommand(checkExist, con))
                {
                    cmdCheck.Parameters.AddWithValue("@FromUserId", fromUserId);
                    cmdCheck.Parameters.AddWithValue("@ToUserId", toUserId);
                    int alreadyExists = (int)cmdCheck.ExecuteScalar();

                    if (alreadyExists > 0)
                    {
                        return Json(new { success = false, message = "You are already following this user." });
                    }
                }

                // Already sent friend request check 
                string checkRequest = @"SELECT COUNT(*) FROM FriendRequests 
                                WHERE from_user_id = @FromUserId AND to_user_id = @ToUserId AND status = 'Pending'";

                using (SqlCommand cmdRequest = new SqlCommand(checkRequest, con))
                {
                    cmdRequest.Parameters.AddWithValue("@FromUserId", fromUserId);
                    cmdRequest.Parameters.AddWithValue("@ToUserId", toUserId);
                    int alreadyRequested = (int)cmdRequest.ExecuteScalar();

                    if (alreadyRequested > 0)
                    {
                        return Json(new { success = false, message = "You already sent a request." });
                    }
                }

                //  Insert into FriendRequests table
                string insertQuery = @"INSERT INTO FriendRequests (from_user_id, to_user_id, request_date, status)
                               VALUES (@FromUserId, @ToUserId, GETDATE(), 'Pending')";

                using (SqlCommand cmdInsert = new SqlCommand(insertQuery, con))
                {
                    cmdInsert.Parameters.AddWithValue("@FromUserId", fromUserId);
                    cmdInsert.Parameters.AddWithValue("@ToUserId", toUserId);

                    int rowsAffected = cmdInsert.ExecuteNonQuery();

                    if (rowsAffected > 0)
                    {
                        return Json(new { success = true });
                    }
                    else
                    {
                        return Json(new { success = false, message = "Failed to send request." });
                    }
                }
            }
        }



        private int GetCurrentUserId()
        {
            return Convert.ToInt32(Session["UserId"]);
        }



        [HttpPost]
        public JsonResult CancelRequest(int toUserId)
        {
            int fromUserId = Convert.ToInt32(Session["UserId"]);

            bool cancelled = DatabaseHelper.CancelFriendRequest(fromUserId, toUserId);
            return Json(new { success = cancelled, message = cancelled ? "Friend request cancelled." : "Error cancelling request." });
        }

        
        [HttpPost]
        public JsonResult AcceptRequest(int requestId)
        {
            var request = DatabaseHelper.GetFriendRequestById(requestId);
            if (request == null)
                return Json(new { success = false, message = "Request not found." });

            bool result = DatabaseHelper.AcceptRequest(request.FromUserId, request.ToUserId);
            return Json(new { success = result });
        }


        [HttpPost]
        public JsonResult UpdateStats(int followerId, int followingId)
        {
            try
            {
                // Count followers
                string followerQuery = "SELECT COUNT(*) FROM followers WHERE following_user_id = @UserId";
                // Count following
                string followingQuery = "SELECT COUNT(*) FROM followers WHERE follower_user_id = @UserId";

                int followersCount = 0;
                int followingCount = 0;

                using (SqlConnection con = new SqlConnection(connectionString))
                {
                    con.Open();

                    // Followers
                    using (SqlCommand cmd = new SqlCommand(followerQuery, con))
                    {
                        cmd.Parameters.AddWithValue("@UserId", followingId);
                        followersCount = (int)cmd.ExecuteScalar();
                    }

                    // Following
                    using (SqlCommand cmd = new SqlCommand(followingQuery, con))
                    {
                        cmd.Parameters.AddWithValue("@UserId", followerId);
                        followingCount = (int)cmd.ExecuteScalar();
                    }
                }

                return Json(new
                {
                    success = true,
                    followers = followersCount,
                    following = followingCount
                });
            }
            catch (Exception ex)
            {
                return Json(new { success = false, message = ex.Message });
            }
        }


        [HttpPost]
        public JsonResult Reject(int requestId)
        {
            bool updated = DatabaseHelper.UpdateRequestStatus(requestId, "Rejected");
            return Json(new { success = updated });
        }

        [HttpGet]
        public JsonResult GetRequests()
        {
            int userId = Convert.ToInt32(Session["UserId"]);
            List<FriendRequestModel> requests = DatabaseHelper.GetPendingRequests(userId);
            return Json(requests, JsonRequestBehavior.AllowGet);
        }


        [HttpGet]
        public JsonResult HasNew()
        {
            int userId = Convert.ToInt32(Session["UserId"]);
            bool hasNew = DatabaseHelper.HasNewRequests(userId);
            return Json(new { hasNew }, JsonRequestBehavior.AllowGet);
        }

        [HttpGet]
        public JsonResult CheckFollowStatus(int toUserId)
        {
            if (Session["UserId"] == null)
            {
                return Json(new { isFollowing = false, message = "Not logged in" }, JsonRequestBehavior.AllowGet);
            }

            int fromUserId = Convert.ToInt32(Session["UserId"]);
            bool isFollowing = DatabaseHelper.IsFollowing(fromUserId, toUserId);

            return Json(new { isFollowing = isFollowing }, JsonRequestBehavior.AllowGet);
        }

        [HttpPost]
        public JsonResult UnfollowUser(int toUserId)
        {
            int fromUserId = Convert.ToInt32(Session["UserId"]);

            string query = @"DELETE FROM followers 
                     WHERE follower_user_id = @FromUserId AND following_user_id = @ToUserId";

            using (SqlConnection con = new SqlConnection(connectionString))
            {
                con.Open();
                using (SqlCommand cmd = new SqlCommand(query, con))
                {
                    cmd.Parameters.AddWithValue("@FromUserId", fromUserId);
                    cmd.Parameters.AddWithValue("@ToUserId", toUserId);

                    int rowsAffected = cmd.ExecuteNonQuery();

                    if (rowsAffected > 0)
                    {
                        return Json(new { success = true });
                    }
                    else
                    {
                        return Json(new { success = false, message = "Unfollow failed or record not found." });
                    }
                }
            }
        }

    }
}