package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"strings"

	_ "github.com/lib/pq"
)

func connectDB(config Config) (*sql.DB, error) {
	connStr := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
		config.DBHost, config.DBPort, config.DBUser, config.DBPassword, config.DBName)

	db, err := sql.Open("postgres", connStr)
	if err != nil {
		return nil, err
	}

	if err := db.Ping(); err != nil {
		return nil, err
	}

	return db, nil
}

func fetchClientsData(db *sql.DB, useManual bool) (map[string]ClientData, error) {
	tableName := "sp_info"
	if useManual {
		tableName = "manual_info"
	}

	// aliases это JSON массив в БД, конвертируем в текст через ::text
	query := fmt.Sprintf(`
		SELECT DISTINCT 
			COALESCE(a.client_title, 'Unknown') as client_title,
			s.sid,
			s.domain_name,
			COALESCE(s.aliases::text, 'null') as aliases
		FROM %s s
		LEFT JOIN apps_settings a ON s.sid = a.l7resourceid
		WHERE s.sid IS NOT NULL
		ORDER BY COALESCE(a.client_title, 'Unknown'), s.sid
	`, tableName)

	rows, err := db.Query(query)
	if err != nil {
		return nil, fmt.Errorf("query failed: %w", err)
	}
	defer rows.Close()

	clients := make(map[string]ClientData)

	for rows.Next() {
		var clientTitle, sid, domainName, aliasesJSON string

		if err := rows.Scan(&clientTitle, &sid, &domainName, &aliasesJSON); err != nil {
			return nil, fmt.Errorf("scan failed: %w", err)
		}

		// Распарсить JSON массив aliases
		aliasesStr := parseAliasesJSON(aliasesJSON)

		if _, exists := clients[clientTitle]; !exists {
			clients[clientTitle] = ClientData{
				ClientTitle: clientTitle,
				Domains:     []DomainInfo{},
			}
		}

		client := clients[clientTitle]
		client.Domains = append(client.Domains, DomainInfo{
			SID:        sid,
			DomainName: domainName,
			Aliases:    aliasesStr,
		})
		clients[clientTitle] = client
	}

	return clients, rows.Err()
}

// parseAliasesJSON конвертирует JSON массив aliases в строку
// Input: ["domain1.com", "domain2.com"] или null
// Output: "domain1.com, domain2.com" или ""
func parseAliasesJSON(jsonStr string) string {
	// Если null или пустое
	if jsonStr == "" || jsonStr == "null" {
		return ""
	}

	// Попытаться распарсить как JSON массив
	var aliases []string
	if err := json.Unmarshal([]byte(jsonStr), &aliases); err != nil {
		// Если не удалось распарсить - вернуть как есть
		log.Printf("Warning: Failed to parse aliases JSON: %s (error: %v)", jsonStr, err)
		return jsonStr
	}

	// Соединить через запятую
	return strings.Join(aliases, ", ")
}