utils.go

package ffsendgo

import (
	"archive/tar"
	"compress/gzip"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"time"

	"github.com/imbecility/go-fake-useragent/useragent"
)

// HumanReadableSize преобразует размер в байтах (int64) в человекочитаемую строку
func HumanReadableSize(bytes int64) string {
	const unit = 1024
	if bytes < unit {
		return fmt.Sprintf("%d B", bytes)
	}
	div, exp := int64(unit), 0
	for n := bytes / unit; n >= unit; n /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
}

// HumanReadableDuration преобразует секунды (int) в человекочитаемую строку времени с точностью до дней
func HumanReadableDuration(seconds int) string {
	if seconds <= 0 {
		return "0 сек."
	}
	var parts []string
	d := time.Duration(seconds) * time.Second
	day := 24 * time.Hour

	if d >= day {
		days := d / day
		parts = append(parts, fmt.Sprintf("%d дн.", days))
		d %= day
	}
	if d >= time.Hour {
		hours := d / time.Hour
		parts = append(parts, fmt.Sprintf("%d час.", hours))
		d %= time.Hour
	}
	if d >= time.Minute {
		minutes := d / time.Minute
		parts = append(parts, fmt.Sprintf("%d мин.", minutes))
		d %= time.Minute
	}
	if d >= time.Second {
		secs := d / time.Second
		parts = append(parts, fmt.Sprintf("%d сек.", secs))
	}

	return strings.Join(parts, " ")
}

// addFileToTar добавляет один файл в tar-архив.
// tarPath - путь файла внутри архива.
func addFileToTar(tw *tar.Writer, filePath, tarPath string) (err error) {
	file, err := os.Open(filePath)
	if err != nil {
		return fmt.Errorf("не удалось открыть файл '%s': %w", filePath, err)
	}

	defer func() {
		if closeErr := file.Close(); closeErr != nil {
			if err == nil { // Не затираем предыдущую ошибку
				err = fmt.Errorf("не удалось закрыть файл '%s': %w", filePath, closeErr)
			}
		}
	}()

	info, err := file.Stat()
	if err != nil {
		return fmt.Errorf("не удалось получить информацию о файле '%s': %w", filePath, err)
	}

	header, err := tar.FileInfoHeader(info, info.Name())
	if err != nil {
		return fmt.Errorf("не удалось создать заголовок для '%s': %w", filePath, err)
	}
	header.Name = tarPath // кастомный путь внутри архива

	if err = tw.WriteHeader(header); err != nil {
		return fmt.Errorf("не удалось записать заголовок для '%s': %w", filePath, err)
	}

	if _, err = io.Copy(tw, file); err != nil {
		return fmt.Errorf("не удалось скопировать содержимое файла '%s': %w", filePath, err)
	}

	return nil
}

// createTarGzArchive создает tar.gz архив из указанной директории или файла.
// возвращает путь к временному файлу архива и функцию для его очистки.
func createTarGzArchive(inputPath string) (string, func(), error) {
	tempFile, err := os.CreateTemp("", "ffsendgo-archive-*.tar.gz")
	if err != nil {
		return "", nil, fmt.Errorf("не удалось создать временный файл для архива: %w", err)
	}
	tempFilePath := tempFile.Name()
	cleanup := func() {
		_ = os.Remove(tempFilePath)
		log.Printf("🗑️ временный архив %s удален.", tempFilePath)
	}

	var errOccurred bool // флаг для отслеживания ошибок в defer

	defer func() {
		// при ошибке нужно удалять временный файл
		if errOccurred {
			cleanup()
		}
	}()

	gzipWriter := gzip.NewWriter(tempFile)

	tarWriter := tar.NewWriter(gzipWriter)

	defer func() {
		if err := tarWriter.Close(); err != nil {
			log.Printf("ошибка при закрытии tar.Writer: %v", err)
		}
		if err := gzipWriter.Close(); err != nil {
			log.Printf("ошибка при закрытии gzip.Writer: %v", err)
		}
		if err := tempFile.Close(); err != nil {
			log.Printf("ошибка при закрытии временного файла: %v", err)
		}
	}()

	info, err := os.Stat(inputPath)
	if err != nil {
		errOccurred = true
		return "", nil, fmt.Errorf("не удалось получить информацию о '%s': %w", inputPath, err)
	}

	if info.IsDir() {
		log.Printf("📦 архивирование директории '%s' в tar.gz...", inputPath)
		baseDir := filepath.Dir(inputPath)
		err = filepath.Walk(inputPath, func(path string, fi os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if path == tempFilePath || fi.IsDir() { // пропуск самого архива и директорий
				return nil
			}

			// относительный путь для архива
			relPath, err := filepath.Rel(baseDir, path)
			if err != nil {
				return err
			}

			return addFileToTar(tarWriter, path, filepath.ToSlash(relPath))
		})
	} else {
		log.Printf("📦 архивирование файла '%s' в tar.gz...", inputPath)
		err = addFileToTar(tarWriter, inputPath, filepath.Base(inputPath))
	}

	// закрытие всех Writer, чтобы данные сбросились в файл
	if err := tarWriter.Close(); err != nil {
		errOccurred = true
		return "", nil, fmt.Errorf("ошибка при финализации tar архива: %w", err)
	}
	if err := gzipWriter.Close(); err != nil {
		errOccurred = true
		return "", nil, fmt.Errorf("ошибка при финализации gzip архива: %w", err)
	}
	if err := tempFile.Close(); err != nil {
		errOccurred = true
		return "", nil, fmt.Errorf("ошибка при закрытии временного файла: %w", err)
	}
	if err != nil {
		errOccurred = true
		return "", nil, fmt.Errorf("ошибка при создании tar.gz архива: %w", err)
	}

	log.Println("✅ архив успешно создан.")

	return tempFilePath, cleanup, nil
}

// findAllowedMax находит максимальное допустимое значение
func findAllowedMax(allowedValues []int, absoluteLimit int) int {
	maxAllowed := 0
	for _, v := range allowedValues {
		if v <= absoluteLimit && v > maxAllowed {
			maxAllowed = v
		}
	}
	if maxAllowed == 0 {
		return absoluteLimit
	}
	return maxAllowed
}

// fetchProviderConfig получает лимиты провайдера
func fetchProviderConfig(providerURL string, client *http.Client) (*ProviderInfo, error) {
	req, err := http.NewRequest("GET", providerURL, nil)
	if err != nil {
		return nil, fmt.Errorf("не удалось создать запрос: %w", err)
	}

	ua, _ := useragent.NewGenerator(
		useragent.WithDiskCache("", 72*time.Hour),
	)

	browserHeaders := ua.GetHeaders(providerURL)

	for key, value := range browserHeaders {
		req.Header.Set(key, value)
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("ошибка при выполнении запроса: %w", err)
	}
	defer func() {
		err = errors.Join(err, resp.Body.Close())
	}()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("сервер вернул статус %d", resp.StatusCode)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("не удалось прочитать тело ответа: %w", err)
	}

	matches := ffSendServerConfigRegex.FindSubmatch(body)
	if len(matches) < 3 {
		return nil, fmt.Errorf("не удалось найти конфигурацию LIMITS и DEFAULTS на странице")
	}

	var limits ServerLimits
	if err := json.Unmarshal(matches[1], &limits); err != nil {
		return nil, fmt.Errorf("ошибка парсинга LIMITS: %w", err)
	}

	var defaults ServerDefaults
	if err := json.Unmarshal(matches[2], &defaults); err != nil {
		return nil, fmt.Errorf("ошибка парсинга DEFAULTS: %w", err)
	}

	maxDownloads := findAllowedMax(defaults.DownloadCounts, limits.MaxDownloads)
	maxExpireTime := findAllowedMax(defaults.ExpireTimesSeconds, limits.MaxExpireSeconds)

	return &ProviderInfo{
		URL:              providerURL,
		MaxFileSize:      limits.MaxFileSize,
		MaxDownloads:     maxDownloads,
		MaxExpireSeconds: maxExpireTime,
	}, nil
}

// getFallbackProviders берет лимиты известных провайдеров из захардкоженного списка
func getFallbackProviders() (map[string]ProviderInfo, error) {
	var providers []ProviderInfo
	if err := json.Unmarshal([]byte(fallbackProvidersJSON), &providers); err != nil {
		return nil, fmt.Errorf("критическая ошибка: не удалось распарсить встроенный список провайдеров: %w", err)
	}
	providerMap := make(map[string]ProviderInfo, len(providers))
	for _, p := range providers {
		providerMap[p.URL] = p
	}
	return providerMap, nil
}

// getOnlineProviders получает актуальные данные о провайдеров из instancesURL
func getOnlineProviders(client *http.Client) ([]string, error) {
	resp, err := client.Get(instancesURL)
	if err != nil {
		return nil, fmt.Errorf("не удалось загрузить список инстансов: %w", err)
	}

	defer func() {
		err = errors.Join(err, resp.Body.Close())
	}()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("не удалось загрузить список инстансов, статус: %s", resp.Status)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("не удалось прочитать ответ со списком инстансов: %w", err)
	}

	var instances []InstanceStatus
	if err := json.Unmarshal(body, &instances); err != nil {
		return nil, fmt.Errorf("ошибка парсинга JSON со списком инстансов: %w", err)
	}

	var onlineProviders []string
	for _, inst := range instances {
		if inst.Status == "up" {
			onlineProviders = append(onlineProviders, strings.TrimSpace(inst.URL))
		}
	}
	return onlineProviders, nil
}

// getInstances управляет получением данных об инстансах провайдеров из всех источников и кешированием
func getInstances() ([]ProviderInfo, error) {
	cacheDir, _ := os.UserCacheDir()
	cacheFile := filepath.Join(cacheDir, "ffsendgo", "providers.json")

	if fileInfo, err := os.Stat(cacheFile); err == nil && time.Since(fileInfo.ModTime()) < 24*time.Hour {
		content, err := os.ReadFile(cacheFile)
		if err == nil {
			var cachedProviders []ProviderInfo
			if json.Unmarshal(content, &cachedProviders) == nil {
				log.Println("✅ загружены рабочие инстансы из кэша.")
				return cachedProviders, nil
			}
		}
	}

	log.Println("🔎 поиск и проверка рабочих инстансов...")
	client := &http.Client{Timeout: 10 * time.Second}
	fallbackData, _ := getFallbackProviders()
	onlineProviderURLs, err := getOnlineProviders(client)
	if err != nil {
		log.Printf("⚠️ не удалось получить онлайн-список: %v.\nиспользуется резервный список.", err)
		onlineProviderURLs = make([]string, 0, len(fallbackData))
		for instanceUrl := range fallbackData {
			onlineProviderURLs = append(onlineProviderURLs, instanceUrl)
		}
	}

	urlsToProcessSet := make(map[string]struct{})
	for _, instanceUrl := range onlineProviderURLs {
		urlsToProcessSet[instanceUrl] = struct{}{}
	}
	for instanceUrl := range fallbackData {
		urlsToProcessSet[instanceUrl] = struct{}{}
	}

	var providers []string
	for instanceUrl := range urlsToProcessSet {
		providers = append(providers, instanceUrl)
	}

	var wg sync.WaitGroup
	resultsChan := make(chan ProviderInfo, len(providers))
	providerChan := make(chan string, len(providers))

	for i := 0; i < 8; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for providerURL := range providerChan {
				info, err := fetchProviderConfig(providerURL, client)
				if err != nil {
					if strings.Contains(err.Error(), "статус 403") || strings.Contains(err.Error(), "статус 401") {
						log.Printf("⚠️ главная страница инстанса %s защищена от ботов.\nпоиск лимитов в резервных источниках...", providerURL)
						if fallbackInfo, ok := fallbackData[providerURL]; ok {
							log.Printf("   -> найдены данные в резервном списке для %s.", providerURL)
							resultsChan <- fallbackInfo
						} else {
							log.Printf("   -> резервных данных нет, используются мин. лимиты по умолчанию для %s.", providerURL)
							resultsChan <- ProviderInfo{
								URL:              providerURL,
								MaxFileSize:      minDefaultFileSize,
								MaxDownloads:     minDefaultDownloads,
								MaxExpireSeconds: minDefaultExpireSeconds,
							}
						}
					} else {
						log.Printf("🔻 инстанс %s недоступен: %s", providerURL, err.Error())
						resultsChan <- ProviderInfo{URL: providerURL, Error: err.Error()}
					}
				} else {
					resultsChan <- *info // успешное получение конфига
				}
			}
		}()
	}

	for _, p := range providers {
		providerChan <- p
	}
	close(providerChan)
	wg.Wait()
	close(resultsChan)

	var successfulProviders []ProviderInfo
	for info := range resultsChan {
		if info.Error == "" {
			successfulProviders = append(successfulProviders, info)
		}
	}

	if len(successfulProviders) == 0 {
		return nil, fmt.Errorf("не найдено ни одного рабочего инстанса")
	}

	log.Printf("👍 найдено %d рабочих инстансов", len(successfulProviders))

	// кэширование
	if cacheDir != "" {
		_ = os.MkdirAll(filepath.Dir(cacheFile), 0755)
		jsonData, _ := json.MarshalIndent(successfulProviders, "", "  ")
		_ = os.WriteFile(cacheFile, jsonData, 0644)
	}
	return successfulProviders, nil
}

// IsPathExists проверяет существование пути, при успехе возвращает путь и os.FileInfo, иначе - ошибку
func IsPathExists(inputPath string) (targetPath string, targetInfo os.FileInfo, err error) {
	stat, err := os.Stat(inputPath)

	if err != nil {
		if os.IsNotExist(err) {
			// файл не существует
			return "", nil, fmt.Errorf("❗️указанный файл/папка '%s' не существует", inputPath)
		}
		// какие-то другие ошибки
		return "", nil, fmt.Errorf("❗️не удалось получить доступ к '%s': %w", inputPath, err)
	}
	return inputPath, stat, nil
}

// prepareUploadTarget подготавливает любой входной путь и возвращает путь до файла
func prepareUploadTarget(inputPath string) (targetPath string, targetInfo os.FileInfo, cleanup func(), err error) {
	_, stat, err := IsPathExists(inputPath)
	if err != nil {
		return "", nil, nil, err
	}

	cleanup = func() {}
	if stat.IsDir() {
		log.Printf("создание tar.gz-аархива из папки '%s'...", inputPath)
		archivePath, cleanupFunc, err := createTarGzArchive(inputPath)
		if err != nil {
			return "", nil, nil, fmt.Errorf("❗️не удалось создать архив из директории: %w", err)
		}
		cleanup = cleanupFunc
		archiveStat, err := os.Stat(archivePath)
		if err != nil {
			cleanup()
			return "", nil, nil, fmt.Errorf("❗️не удалось получить информацию о созданном архиве '%s': %w", archivePath, err)
		}
		log.Printf("📦 архив '%s' создан, размер: %s", filepath.Base(archivePath), HumanReadableSize(archiveStat.Size()))
		return archivePath, archiveStat, cleanup, nil
	}
	log.Printf("📄 файл: '%s', размер: %s", filepath.Base(inputPath), HumanReadableSize(stat.Size()))
	return inputPath, stat, cleanup, nil
}

// findAndSelectHosts
func findAndSelectHosts(fileSize int64) ([]ProviderInfo, error) {
	providers, err := getInstances()
	if err != nil {
		return nil, fmt.Errorf("не удалось найти рабочие инстансы: %w", err)
	}

	var suitableProviders []ProviderInfo
	for _, p := range providers {
		if p.MaxFileSize >= fileSize {
			suitableProviders = append(suitableProviders, p)
		}
	}

	if len(suitableProviders) == 0 {
		return nil, fmt.Errorf("не найдено инстансов, поддерживающих загрузку файла размером %s", HumanReadableSize(fileSize))
	}

	log.Println("🔀 подбор подходящих инстансов по лучшим условиям...")
	sort.Slice(suitableProviders, func(i, j int) bool {
		if suitableProviders[i].MaxExpireSeconds != suitableProviders[j].MaxExpireSeconds {
			return suitableProviders[i].MaxExpireSeconds > suitableProviders[j].MaxExpireSeconds
		}
		return suitableProviders[i].MaxDownloads > suitableProviders[j].MaxDownloads
	})

	log.Printf("✅ найдено %d подходящих инстансов.\n👍лучший: %s (жизнь: %s, скачиваний: %d)",
		len(suitableProviders),
		suitableProviders[0].URL,
		HumanReadableDuration(suitableProviders[0].MaxExpireSeconds),
		suitableProviders[0].MaxDownloads,
	)

	return suitableProviders, nil
}