package api

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"sort"
	"strings"
	"sync"
	"time"

	"task-dashboard/internal/models"
)

const (
	trelloBaseURL = "https://api.trello.com/1"
)

// TrelloClient handles interactions with the Trello API
type TrelloClient struct {
	apiKey     string
	token      string
	baseURL    string
	httpClient *http.Client
}

// NewTrelloClient creates a new Trello API client
func NewTrelloClient(apiKey, token string) *TrelloClient {
	return &TrelloClient{
		apiKey:  apiKey,
		token:   token,
		baseURL: trelloBaseURL,
		httpClient: &http.Client{
			Timeout: 30 * time.Second,
		},
	}
}

// trelloBoardResponse represents a board from the API
type trelloBoardResponse struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

// trelloCardResponse represents a card from the API
type trelloCardResponse struct {
	ID      string  `json:"id"`
	Name    string  `json:"name"`
	IDList  string  `json:"idList"`
	Due     *string `json:"due"`
	URL     string  `json:"url"`
	Desc    string  `json:"desc"`
	IDBoard string  `json:"idBoard"`
}

// trelloListResponse represents a list from the API
type trelloListResponse struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

// GetBoards fetches all boards for the authenticated user
func (c *TrelloClient) GetBoards(ctx context.Context) ([]models.Board, error) {
	params := url.Values{}
	params.Set("key", c.apiKey)
	params.Set("token", c.token)
	params.Set("filter", "open")
	params.Set("fields", "id,name") // Only fetch required fields

	reqURL := fmt.Sprintf("%s/members/me/boards?%s", c.baseURL, params.Encode())
	req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch boards: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("trello API error (status %d): %s", resp.StatusCode, string(body))
	}

	var apiBoards []trelloBoardResponse
	if err := json.NewDecoder(resp.Body).Decode(&apiBoards); err != nil {
		return nil, fmt.Errorf("failed to decode response: %w", err)
	}

	// Convert to our model
	boards := make([]models.Board, 0, len(apiBoards))
	for _, apiBoard := range apiBoards {
		board := models.Board{
			ID:    apiBoard.ID,
			Name:  apiBoard.Name,
			Cards: []models.Card{}, // Will be populated by GetCards
		}
		boards = append(boards, board)
	}

	return boards, nil
}

// GetCards fetches all cards for a specific board
func (c *TrelloClient) GetCards(ctx context.Context, boardID string) ([]models.Card, error) {
	params := url.Values{}
	params.Set("key", c.apiKey)
	params.Set("token", c.token)
	params.Set("filter", "visible")
	params.Set("fields", "id,name,idList,due,url,idBoard") // Only fetch required fields

	reqURL := fmt.Sprintf("%s/boards/%s/cards?%s", c.baseURL, boardID, params.Encode())
	req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch cards: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("trello API error (status %d): %s", resp.StatusCode, string(body))
	}

	var apiCards []trelloCardResponse
	if err := json.NewDecoder(resp.Body).Decode(&apiCards); err != nil {
		return nil, fmt.Errorf("failed to decode response: %w", err)
	}

	log.Printf("Trello GetCards: board %s returned %d cards from API", boardID, len(apiCards))

	// Fetch lists to get list names
	lists, err := c.getLists(ctx, boardID)
	listMap := make(map[string]string)
	if err == nil {
		// Build map of list ID to name
		for _, list := range lists {
			listMap[list.ID] = list.Name
		}
	}

	// Convert to our model
	cards := make([]models.Card, 0, len(apiCards))
	for _, apiCard := range apiCards {
		card := models.Card{
			ID:       apiCard.ID,
			Name:     apiCard.Name,
			ListID:   apiCard.IDList,
			ListName: listMap[apiCard.IDList],
			URL:      apiCard.URL,
		}

		// Parse due date if present
		if apiCard.Due != nil && *apiCard.Due != "" {
			dueDate, err := time.Parse(time.RFC3339, *apiCard.Due)
			if err == nil {
				card.DueDate = &dueDate
			}
		}

		cards = append(cards, card)
	}

	return cards, nil
}

// getLists fetches lists for a board
func (c *TrelloClient) getLists(ctx context.Context, boardID string) ([]models.List, error) {
	params := url.Values{}
	params.Set("key", c.apiKey)
	params.Set("token", c.token)
	params.Set("fields", "id,name") // Only fetch required fields

	reqURL := fmt.Sprintf("%s/boards/%s/lists?%s", c.baseURL, boardID, params.Encode())
	req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch lists: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("trello API error (status %d): %s", resp.StatusCode, string(body))
	}

	var apiLists []trelloListResponse
	if err := json.NewDecoder(resp.Body).Decode(&apiLists); err != nil {
		return nil, fmt.Errorf("failed to decode response: %w", err)
	}

	// Convert to model
	lists := make([]models.List, 0, len(apiLists))
	for _, apiList := range apiLists {
		lists = append(lists, models.List{
			ID:   apiList.ID,
			Name: apiList.Name,
		})
	}

	return lists, nil
}

// GetLists fetches lists for a specific board
func (c *TrelloClient) GetLists(ctx context.Context, boardID string) ([]models.List, error) {
	return c.getLists(ctx, boardID)
}

// GetBoardsWithCards fetches all boards and their cards in one call
func (c *TrelloClient) GetBoardsWithCards(ctx context.Context) ([]models.Board, error) {
	boards, err := c.GetBoards(ctx)
	if err != nil {
		return nil, err
	}

	var wg sync.WaitGroup
	sem := make(chan struct{}, 5) // Limit to 5 concurrent requests

	for i := range boards {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()

			// Acquire semaphore
			sem <- struct{}{}
			defer func() { <-sem }()

			// Fetch cards
			cards, err := c.GetCards(ctx, boards[i].ID)
			if err != nil {
				log.Printf("Error fetching cards for board %s (%s): %v", boards[i].Name, boards[i].ID, err)
			} else {
				// Set BoardName for each card
				for j := range cards {
					cards[j].BoardName = boards[i].Name
				}
				// It is safe to write to specific indices of the slice concurrently
				boards[i].Cards = cards
			}

			// Fetch lists
			lists, err := c.getLists(ctx, boards[i].ID)
			if err != nil {
				log.Printf("Error fetching lists for board %s: %v", boards[i].Name, err)
			} else {
				boards[i].Lists = lists
			}
		}(i)
	}

	wg.Wait()

	// Sort boards: Non-empty boards first, newest card activity, then alphabetical by name
	// Trello card IDs are chronologically sortable (newer IDs > older IDs)
	sort.Slice(boards, func(i, j int) bool {
		hasCardsI := len(boards[i].Cards) > 0
		hasCardsJ := len(boards[j].Cards) > 0

		// 1. Prioritize boards with cards
		if hasCardsI != hasCardsJ {
			return hasCardsI // true (non-empty) comes before false
		}

		// 2. If both have cards, compare by newest card (max ID)
		if hasCardsI && hasCardsJ {
			maxIDI := ""
			for _, card := range boards[i].Cards {
				if maxIDI == "" || card.ID > maxIDI {
					maxIDI = card.ID
				}
			}

			maxIDJ := ""
			for _, card := range boards[j].Cards {
				if maxIDJ == "" || card.ID > maxIDJ {
					maxIDJ = card.ID
				}
			}

			if maxIDI != maxIDJ {
				return maxIDI > maxIDJ // Newer (larger) ID comes first
			}
		}

		// 3. Fallback to alphabetical by name
		return boards[i].Name < boards[j].Name
	})

	return boards, nil
}

// CreateCard creates a new card in the specified list
func (c *TrelloClient) CreateCard(ctx context.Context, listID, name, description string, dueDate *time.Time) (*models.Card, error) {
	// Prepare request payload
	data := url.Values{}
	data.Set("key", c.apiKey)
	data.Set("token", c.token)
	data.Set("idList", listID)
	data.Set("name", name)

	if description != "" {
		data.Set("desc", description)
	}

	if dueDate != nil {
		data.Set("due", dueDate.Format(time.RFC3339))
	}

	// Create POST request
	reqURL := c.baseURL + "/cards"
	req, err := http.NewRequestWithContext(ctx, "POST", reqURL, strings.NewReader(data.Encode()))
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	// Execute request
	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to create card: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("trello API error (status %d): %s", resp.StatusCode, string(body))
	}

	// Decode response
	var apiCard trelloCardResponse
	if err := json.NewDecoder(resp.Body).Decode(&apiCard); err != nil {
		return nil, fmt.Errorf("failed to decode response: %w", err)
	}

	// Convert to our model
	card := &models.Card{
		ID:     apiCard.ID,
		Name:   apiCard.Name,
		ListID: apiCard.IDList,
		URL:    apiCard.URL,
	}

	// Parse due date if present
	if apiCard.Due != nil && *apiCard.Due != "" {
		parsedDate, err := time.Parse(time.RFC3339, *apiCard.Due)
		if err == nil {
			card.DueDate = &parsedDate
		}
	}

	return card, nil
}

// UpdateCard updates a card with the specified changes
func (c *TrelloClient) UpdateCard(ctx context.Context, cardID string, updates map[string]interface{}) error {
	// Prepare request payload
	data := url.Values{}
	data.Set("key", c.apiKey)
	data.Set("token", c.token)

	// Add updates to payload
	for key, value := range updates {
		data.Set(key, fmt.Sprintf("%v", value))
	}

	// Create PUT request
	reqURL := fmt.Sprintf("%s/cards/%s", c.baseURL, cardID)
	req, err := http.NewRequestWithContext(ctx, "PUT", reqURL, strings.NewReader(data.Encode()))
	if err != nil {
		return fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

	// Execute request
	resp, err := c.httpClient.Do(req)
	if err != nil {
		return fmt.Errorf("failed to update card: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("trello API error (status %d): %s", resp.StatusCode, string(body))
	}

	return nil
}