package models

import "database/sql"

type Like struct {
	ID     int
	PostID int
	UserID int
	Type   string // "like" or "dislike"
}

func GetLikesByPostID(db *sql.DB, postID int) ([]Like, error) {
	query := "SELECT id, post_id, user_id, type FROM likes WHERE post_id = ?"
	rows, err := db.Query(query, postID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var likes []Like
	for rows.Next() {
		like := Like{}
		err := rows.Scan(&like.ID, &like.PostID, &like.UserID, &like.Type)
		if err != nil {
			return nil, err
		}
		likes = append(likes, like)
	}
	return likes, nil
}

func GetLikeByPostAndUser(db *sql.DB, postID, userID int) (*Like, error) {
	query := "SELECT id, post_id, user_id, type FROM likes WHERE post_id = ? AND user_id = ?"
	row := db.QueryRow(query, postID, userID)
	like := &Like{}
	err := row.Scan(&like.ID, &like.PostID, &like.UserID, &like.Type)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return like, nil
}

func CreateLike(db *sql.DB, like Like) error {
	query := "INSERT INTO likes (post_id, user_id, type) VALUES (?, ?, ?)"
	_, err := db.Exec(query, like.PostID, like.UserID, like.Type)
	return err
}

func UpdateLikeType(db *sql.DB, postID, userID int, likeType string) error {
	query := "UPDATE likes SET type = ? WHERE post_id = ? AND user_id = ?"
	_, err := db.Exec(query, likeType, postID, userID)
	return err
}

func DeleteLike(db *sql.DB, postID, userID int) error {
	query := "DELETE FROM likes WHERE post_id = ? AND user_id = ?"
	_, err := db.Exec(query, postID, userID)
	return err
}

type LikeCounts struct {
	Likes    int
	Dislikes int
}

func GetLikeCountsByPostID(db *sql.DB, postID int) (LikeCounts, error) {
	counts := LikeCounts{}
	query := "SELECT COALESCE(SUM(CASE WHEN type='like' THEN 1 ELSE 0 END),0), COALESCE(SUM(CASE WHEN type='dislike' THEN 1 ELSE 0 END),0) FROM likes WHERE post_id = ?"
	err := db.QueryRow(query, postID).Scan(&counts.Likes, &counts.Dislikes)
	return counts, err
}

func GetLikeCountsForPosts(db *sql.DB, postIDs []int) (map[int]LikeCounts, error) {
	result := make(map[int]LikeCounts)
	if len(postIDs) == 0 {
		return result, nil
	}
	// Build placeholders
	placeholders := ""
	args := make([]interface{}, len(postIDs))
	for i, id := range postIDs {
		if i > 0 {
			placeholders += ","
		}
		placeholders += "?"
		args[i] = id
	}
	query := "SELECT post_id, type, COUNT(*) FROM likes WHERE post_id IN (" + placeholders + ") GROUP BY post_id, type"
	rows, err := db.Query(query, args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	for rows.Next() {
		var postID int
		var likeType string
		var count int
		if err := rows.Scan(&postID, &likeType, &count); err != nil {
			return nil, err
		}
		c := result[postID]
		if likeType == "like" {
			c.Likes = count
		} else {
			c.Dislikes = count
		}
		result[postID] = c
	}
	return result, nil
}

func GetUserLikesForPosts(db *sql.DB, userID int, postIDs []int) (map[int]string, error) {
	result := make(map[int]string)
	if len(postIDs) == 0 || userID == 0 {
		return result, nil
	}
	placeholders := ""
	args := make([]interface{}, 0, len(postIDs)+1)
	args = append(args, userID)
	for i, id := range postIDs {
		if i > 0 {
			placeholders += ","
		}
		placeholders += "?"
		args = append(args, id)
	}
	query := "SELECT post_id, type FROM likes WHERE user_id = ? AND post_id IN (" + placeholders + ")"
	rows, err := db.Query(query, args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	for rows.Next() {
		var postID int
		var likeType string
		if err := rows.Scan(&postID, &likeType); err != nil {
			return nil, err
		}
		result[postID] = likeType
	}
	return result, nil
}