main.go

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"sort"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/chromedp/chromedp"
	"golang.org/x/net/html"
	"golang.org/x/net/html/charset"
)

// Глобальные переменные для отслеживания вкладок
var (
	activeClients = make(map[string]bool)
	mu            sync.Mutex
)

// Структуры
type ClientIDRequest struct{ ID string `json:"id"` }
type WikiInfo struct {
	DirName      string `json:"dirname"`
	Title        string `json:"title"`
	Size         int64  `json:"size"`
	ModTime      string `json:"mod_time"`
	TiddlerCount int    `json:"tiddler_count"`
	Favicon      string `json:"favicon"`
	CoreVersion  string `json:"core_version"`
}
type TiddlerJson struct {
	Title    string   `json:"title"`
	Text     string   `json:"text"`
	Type     string   `json:"type,omitempty"`
	Tags     string   `json:"tags,omitempty"`
	Version  string   `json:"version,omitempty"`
	Created  string   `json:"created,omitempty"`
	Modified string   `json:"modified,omitempty"` // Добавлено для полноты данных
	Creator  string   `json:"creator,omitempty"`  // Добавлено для полноты данных
	Modifier string   `json:"modifier,omitempty"` // Добавлено для полноты данных
}

// Вспомогательные функции
func hasClass(n *html.Node, className string) bool { if n.Type == html.ElementNode { for _, attr := range n.Attr { if attr.Key == "class" { classes := strings.Fields(attr.Val); for _, c := range classes { if c == className { return true } } } } }; return false }
func getTitle(n *html.Node) string { if n.Type == html.ElementNode && n.Data == "title" { if n.FirstChild != nil && n.FirstChild.Type == html.TextNode { return n.FirstChild.Data } }; for c := n.FirstChild; c != nil; c = c.NextSibling { if title := getTitle(c); title != "" { return title } }; return "" }
func getTiddlyWikiFavicon(n *html.Node) string { if n.Type == html.ElementNode && n.Data == "script" { for _, attr := range n.Attr { if attr.Key == "type" && attr.Val == "application/json" { if n.FirstChild != nil { var tiddlers []TiddlerJson; if err := json.Unmarshal([]byte(n.FirstChild.Data), &tiddlers); err == nil { for _, t := range tiddlers { if t.Title == "$:/favicon.ico" { return fmt.Sprintf("data:%s;base64,%s", t.Type, t.Text) } } } } } } }; for c := n.FirstChild; c != nil; c = c.NextSibling { if favicon := getTiddlyWikiFavicon(c); favicon != "" { return favicon } }; return "" }
func getAttribute(n *html.Node, key string) string { for _, attr := range n.Attr { if attr.Key == key { return attr.Val } }; return "" }

// findWikis ИСПРАВЛЕННАЯ ВЕРСИЯ
// Добавлена проверка на пустые файлы (info.Size() == 0). Если файл пуст,
// мы его пропускаем, что предотвращает панику сервера при попытке распарсить
// пустые данные. Также улучшена обработка ошибок чтения.
func findWikis(root string, query string) ([]WikiInfo, error) {
	var wikis []WikiInfo
	searchQuery := strings.ToLower(strings.TrimSpace(query))
	filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		// --- НАЧАЛО ИСПРАВЛЕНИЯ ---
		if info.IsDir() || !strings.HasSuffix(info.Name(), ".html") || info.Size() == 0 {
			return nil // Пропускаем директории, не-html файлы и ПУСТЫЕ файлы
		}
		// --- КОНЕЦ ИСПРАВЛЕНИЯ ---

		dirName := filepath.Base(filepath.Dir(path))
		fileNameNoExt := strings.TrimSuffix(info.Name(), ".html")
		if !strings.EqualFold(dirName, fileNameNoExt) {
			return nil
		}
		
		contentBytes, err := os.ReadFile(path)
		if err != nil {
			log.Printf("Предупреждение: не удалось прочитать файл %s: %v", path, err)
			return nil // Пропускаем файл, если не можем его прочитать
		}
		
		utf8Reader, err := charset.NewReader(bytes.NewReader(contentBytes), "")
		if err != nil {
			log.Printf("Предупреждение: не удалось создать utf8Reader для %s: %v", path, err)
			return nil
		}
		
		doc, err := html.Parse(utf8Reader)
		if err != nil {
			log.Printf("Предупреждение: не удалось распарсить HTML из %s: %v", path, err)
			return nil // Пропускаем файл, если HTML некорректен
		}

		var tiddlerCount int
		var coreVersion string

		var storeNode *html.Node
		var findStoreNode func(*html.Node)
		findStoreNode = func(n *html.Node) {
			if n.Type == html.ElementNode {
				if (n.Data == "script" && hasClass(n, "tiddlywiki-tiddler-store")) || (n.Data == "div" && getAttribute(n, "id") == "storeArea") {
					storeNode = n
					return
				}
			}
			for c := n.FirstChild; c != nil && storeNode == nil; c = c.NextSibling { findStoreNode(c) }
		}
		findStoreNode(doc)

		if storeNode != nil && storeNode.FirstChild != nil && storeNode.FirstChild.Type == html.TextNode {
			var tiddlers []TiddlerJson
			if json.Unmarshal([]byte(storeNode.FirstChild.Data), &tiddlers) == nil {
				var count int
				var textContentBuilder strings.Builder
				for _, t := range tiddlers {
					if t.Created != "" { count++ }
					textContentBuilder.WriteString(t.Text + "\n")
					if t.Title == "$:/core" { coreVersion = t.Version }
				}
				tiddlerCount = count
				if searchQuery != "" && !strings.Contains(strings.ToLower(textContentBuilder.String()), searchQuery) { return nil }
			}
		}

		if tiddlerCount == 0 || coreVersion == "" {
			var findMetaVersion func(*html.Node)
			findMetaVersion = func(n *html.Node) {
				if n.Type == html.ElementNode && n.Data == "meta" && getAttribute(n, "name") == "tiddlywiki-version" {
					coreVersion = getAttribute(n, "content")
					return
				}
				for c := n.FirstChild; c != nil && coreVersion == ""; c = c.NextSibling { findMetaVersion(c) }
			}
			findMetaVersion(doc)

			var count int
			var findLegacyTiddlers func(*html.Node)
			findLegacyTiddlers = func(n *html.Node) {
				if n.Type == html.ElementNode && n.Data == "div" && getAttribute(n, "created") != "" { count++ }
				for c := n.FirstChild; c != nil; c = c.NextSibling { findLegacyTiddlers(c) }
			}

			if storeNode != nil { findLegacyTiddlers(storeNode) } else { findLegacyTiddlers(doc) }
			if count > 0 { tiddlerCount = count }

			if searchQuery != "" && !strings.Contains(strings.ToLower(string(contentBytes)), searchQuery) { return nil }
		}

		docTitle := getTitle(doc)
		if docTitle == "" { docTitle = dirName }
		docFavicon := getTiddlyWikiFavicon(doc)

		wikis = append(wikis, WikiInfo{
			DirName:      dirName,
			Title:        docTitle,
			Size:         info.Size(),
			ModTime:      info.ModTime().Format("02.01.2006 15:04"),
			TiddlerCount: tiddlerCount,
			Favicon:      docFavicon,
			CoreVersion:  coreVersion,
		})
		return nil
	})
	sort.Slice(wikis, func(i, j int) bool { return strings.ToLower(wikis[i].DirName) < strings.ToLower(wikis[j].DirName) })
	return wikis, nil
}

// downloadWithChrome использует простую и надежную стратегию безусловной паузы.
func downloadWithChrome(urlToFetch string) ([]byte, error) {
	chromePath, err := findChromePath()
	if err != nil {
		return nil, err
	}
	allocatorCtx, cancel := context.WithTimeout(context.Background(), 120*time.Second)
	defer cancel()

	allocOpts := append(chromedp.DefaultExecAllocatorOptions[:],
		chromedp.ExecPath(chromePath),
		chromedp.Flag("headless", true),
		chromedp.Flag("disable-gpu", true),
		chromedp.Flag("no-sandbox", true),
	)
	ctx, cancel := chromedp.NewExecAllocator(allocatorCtx, allocOpts...)
	defer cancel()

	taskCtx, cancel := chromedp.NewContext(ctx, chromedp.WithLogf(log.Printf))
	defer cancel()

	var htmlContent string
	err = chromedp.Run(taskCtx,
		chromedp.Navigate(urlToFetch),
		chromedp.Sleep(6*time.Second),
		chromedp.OuterHTML("html", &htmlContent, chromedp.ByQuery),
	)

	if err != nil {
		return nil, fmt.Errorf("ошибка ChromeDP: %w", err)
	}
	return []byte(htmlContent), nil
}

func findChromePath() (string, error) { candidates := []string{"google-chrome", "google-chrome-stable", "chromium-browser", "chromium"}; for _, candidate := range candidates { path, err := exec.LookPath(candidate); if err == nil { return path, nil } }; return "", fmt.Errorf("не удалось найти Chrome") }

// importUrlHandler ФИНАЛЬНАЯ РАБОЧАЯ ВЕРСИЯ
// Предыдущий "хирургический" метод был слишком хрупким.
// НОВЫЙ ПОДХОД ("Умная хирургия"):
// 1. Мы ищем не весь тег целиком, а его надежный "якорь": class="tiddlywiki-tiddler-store".
// 2. От этого якоря находим конец открывающего тега ('>').
// 3. Оттуда находим начало закрывающего тега ('</script>').
// 4. Это дает нам точные границы содержимого, независимо от порядка атрибутов.
// 5. Мы заменяем только содержимое, оставляя оригинальные теги нетронутыми.
func importUrlHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Получен запрос на импорт URL (финальная логика)...")
	var requestData map[string]string
	if err := json.NewDecoder(r.Body).Decode(&requestData); err != nil {
		http.Error(w, "Неверный запрос", http.StatusBadRequest)
		return
	}
	urlToFetch := requestData["url"]
	dirName := requestData["filename"]
	if urlToFetch == "" || dirName == "" {
		http.Error(w, "URL или имя файла не указаны", http.StatusBadRequest)
		return
	}

	remoteHTML, err := downloadWithChrome(urlToFetch)
	if err != nil {
		http.Error(w, "Не удалось скачать URL.", http.StatusInternalServerError)
		return
	}

	doc, err := html.Parse(bytes.NewReader(remoteHTML))
	if err != nil {
		http.Error(w, "Не удалось разобрать полученный HTML.", http.StatusInternalServerError)
		return
	}

	var tiddlers []*TiddlerJson
	var tiddlerJSON string
	var findJSONStore func(*html.Node)
	findJSONStore = func(n *html.Node) {
		if n.Type == html.ElementNode && n.Data == "script" && getAttribute(n, "type") == "application/json" {
			if n.FirstChild != nil && n.FirstChild.Type == html.TextNode {
				tiddlerJSON = n.FirstChild.Data
				return
			}
		}
		for c := n.FirstChild; c != nil && tiddlerJSON == ""; c = c.NextSibling { findJSONStore(c) }
	}
	findJSONStore(doc)

	if tiddlerJSON != "" {
		if err := json.Unmarshal([]byte(tiddlerJSON), &tiddlers); err != nil {
			http.Error(w, "Ошибка декодирования JSON.", http.StatusInternalServerError)
			return
		}
	} else {
		var storeArea *html.Node
		var findStoreArea func(*html.Node)
		findStoreArea = func(n *html.Node) {
			if n.Type == html.ElementNode && n.Data == "div" && getAttribute(n, "id") == "storeArea" {
				storeArea = n
				return
			}
			for c := n.FirstChild; c != nil && storeArea == nil; c = c.NextSibling { findStoreArea(c) }
		}
		findStoreArea(doc)
		if storeArea != nil {
			var textContent strings.Builder
			var extractText func(*html.Node)
			extractText = func(n *html.Node) {
				if n.Type == html.TextNode { textContent.WriteString(n.Data) }
				for c := n.FirstChild; c != nil; c = c.NextSibling { extractText(c) }
			}
			for c := storeArea.FirstChild; c != nil; c = c.NextSibling {
				if c.Type == html.ElementNode && c.Data == "div" && getAttribute(c, "title") != "" {
					textContent.Reset()
					extractText(c)
					tiddlers = append(tiddlers, &TiddlerJson{
						Title: getAttribute(c, "title"), Tags: getAttribute(c, "tags"), Created: getAttribute(c, "created"), Modified: getAttribute(c, "modified"), Creator: getAttribute(c, "creator"), Modifier: getAttribute(c, "modifier"), Text: textContent.String(),
					})
				}
			}
		}
	}

	if len(tiddlers) == 0 {
		http.Error(w, "Не удалось найти тиддлеры в файле.", http.StatusBadRequest)
		return
	}
	log.Printf("Успешно извлечено %d тиддлеров.", len(tiddlers))

	finalJSON, err := json.MarshalIndent(tiddlers, "", "  ")
	if err != nil {
		http.Error(w, "Ошибка кодирования итогового JSON.", http.StatusInternalServerError)
		return
	}
	
	workDir, err := os.Getwd()
	if err != nil {
		http.Error(w, "Не удалось определить рабочую директорию.", http.StatusInternalServerError)
		return
	}
	templatePath := filepath.Join(workDir, "template.html")
	templateBytes, err := os.ReadFile(templatePath)
	if err != nil {
		http.Error(w, "Не удалось прочитать файл-шаблон.", http.StatusInternalServerError)
		return
	}

	// --- НАЧАЛО НОВОЙ ЛОГИКИ ЗАМЕНЫ ---
	anchor := []byte(`class="tiddlywiki-tiddler-store"`)
	endTag := []byte(`</script>`)

	// 1. Ищем наш надежный якорь
	anchorIndex := bytes.Index(templateBytes, anchor)
	if anchorIndex == -1 {
		http.Error(w, `Не удалось найти якорь 'class="tiddlywiki-tiddler-store"' в шаблоне.`, http.StatusInternalServerError)
		return
	}

	// 2. От якоря ищем конец открывающего тега
	startContentIndex := bytes.Index(templateBytes[anchorIndex:], []byte(">"))
	if startContentIndex == -1 {
		http.Error(w, "Найден якорь, но не найден конец открывающего тега '>' в шаблоне.", http.StatusInternalServerError)
		return
	}
	// Делаем индекс абсолютным и сдвигаем на 1, чтобы он указывал ПОСЛЕ '>'
	startContentIndex += anchorIndex + 1

	// 3. От конца открывающего тега ищем начало закрывающего
	endContentIndex := bytes.Index(templateBytes[startContentIndex:], endTag)
	if endContentIndex == -1 {
		http.Error(w, "Найден открывающий тег, но не найден закрывающий '</script>' в шаблоне.", http.StatusInternalServerError)
		return
	}
	// Делаем индекс абсолютным
	endContentIndex += startContentIndex

	// 4. Собираем новый файл из трех частей
	var finalHTMLBuffer bytes.Buffer
	finalHTMLBuffer.Write(templateBytes[:startContentIndex]) // Часть ДО содержимого
	finalHTMLBuffer.Write(finalJSON)                         // Наш новый JSON
	finalHTMLBuffer.Write(templateBytes[endContentIndex:])   // Часть ПОСЛЕ содержимого
	// --- КОНЕЦ НОВОЙ ЛОГИКИ ЗАМЕНЫ ---

	wikiPath := filepath.Join("tids", "wikis", dirName)
	if err := os.MkdirAll(wikiPath, os.ModePerm); err != nil {
		http.Error(w, "Не удалось создать директорию.", http.StatusInternalServerError)
		return
	}
	filePath := filepath.Join(wikiPath, dirName+".html")
	err = os.WriteFile(filePath, finalHTMLBuffer.Bytes(), 0644)
	if err != nil {
		http.Error(w, "Не удалось сохранить файл.", http.StatusInternalServerError)
		return
	}
	
	log.Printf("Файл '%s' успешно импортирован и пересобран!", dirName)
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{"message": fmt.Sprintf("Файл '%s' успешно импортирован!", dirName)})
}

func deleteWikiHandler(w http.ResponseWriter, r *http.Request) { var requestData map[string]string; if err := json.NewDecoder(r.Body).Decode(&requestData); err != nil { http.Error(w, "Неверный запрос", http.StatusBadRequest); return }; dirName := requestData["dirname"]; if dirName == "" { http.Error(w, "Имя директории не указано", http.StatusBadRequest); return }; dirPath := filepath.Join("tids", "wikis", dirName); if !strings.HasPrefix(dirPath, filepath.Join("tids", "wikis")) { http.Error(w, "Недопустимый путь к директории", http.StatusBadRequest); return }; err := os.RemoveAll(dirPath); if err != nil { log.Printf("Ошибка при удалении директории %s: %v", dirPath, err); http.Error(w, "Не удалось удалить директорию", http.StatusInternalServerError); return }; log.Printf("Директория успешно удалена: %s", dirPath); w.WriteHeader(http.StatusOK); json.NewEncoder(w).Encode(map[string]string{"message": "Вики успешно удален."}) }

// convertHandler ФИНАЛЬНАЯ РАБОЧАЯ ВЕРСИЯ
// Основана на факте, что утилита `tcliconv` не печатает результат в stdout,
// а СОЗДАЕТ ГОТОВЫЙ ФАЙЛ в своей рабочей директории.
// Новая логика:
// 1. Запускает утилиту в ее "родной" директории (`cmd.Dir`).
// 2. После успешного выполнения, сканирует эту директорию и находит
//    самый новый созданный `.html` файл.
// 3. Читает содержимое этого файла.
// 4. Записывает это содержимое в целевую папку нашего приложения (`tids/wikis/...`).
// 5. (Опционально) Удаляет временный файл из директории утилиты.
// convertHandler ФИНАЛЬНАЯ ВЕРСИЯ
// Добавлена логика для автоматической подстановки API-ключа Blogger.
// Ключ хранится как константа прямо на сервере, что избавляет
// пользователя от необходимости вводить его каждый раз.
func convertHandler(w http.ResponseWriter, r *http.Request) {
	// --- НАЧАЛО ИЗМЕНЕНИЙ ---
	const bloggerAPIKey = "AIzaSyChVIBl3BEjxCTDLTjvYYezzbNB74GqEMI" // Ваш ключ здесь
	// --- КОНЕЦ ИЗМЕНЕНИЙ ---

	log.Println("Получен запрос на конвертацию из сети...")
	var reqData map[string]string
	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
		http.Error(w, "Неверный запрос", http.StatusBadRequest)
		return
	}
	platform := reqData["platform"]
	urlToConvert := reqData["url"]
	dirName := reqData["dirname"]
	apiKey := reqData["apiKey"]

	if platform == "" || urlToConvert == "" || dirName == "" {
		http.Error(w, "Не указаны все необходимые параметры", http.StatusBadRequest)
		return
	}
	log.Printf("Делегирую задачу конвертации внутренней утилите для платформы '%s'...", platform)

	workDir, err := os.Getwd()
	if err != nil {
		http.Error(w, "Не удалось определить рабочую директорию", http.StatusInternalServerError)
		return
	}
	
	converterCmdDir := filepath.Join(workDir, "tiddlywiki-converter", "cmd", "tcliconv")
	converterExecutablePath := filepath.Join(converterCmdDir, "tcliconv")
	
	// --- НАЧАЛО ИЗМЕНЕНИЙ ---
	// Собираем аргументы, начиная с базовых
	args := []string{
		"--platform", platform,
		"--url", urlToConvert,
	}

	// Логика для API ключа
	if platform == "blogger" {
		if apiKey != "" {
			// Если ключ пришел в запросе, используем его (гибкость для будущего)
			args = append(args, "--api_key", apiKey)
			log.Println("Используется API ключ, предоставленный в запросе.")
		} else {
			// Если ключ не пришел, используем наш встроенный
			args = append(args, "--api_key", bloggerAPIKey)
			log.Println("Используется встроенный API ключ для Blogger.")
		}
	} else if apiKey != "" {
		// Для других платформ (если появятся)
		args = append(args, "--api_key", apiKey)
	}
	// --- КОНЕЦ ИЗМЕНЕНИЙ ---

	cmd := exec.Command(converterExecutablePath, args...)
	cmd.Dir = converterCmdDir

	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	log.Printf("Выполняю команду: %s в директории %s", cmd.String(), cmd.Dir)
	err = cmd.Run()
	if err != nil {
		log.Printf("Ошибка при выполнении утилиты: %v. Stderr: %s", err, stderr.String())
		http.Error(w, "Ошибка во время конвертации: "+stderr.String(), http.StatusInternalServerError)
		return
	}

	var newestFile os.FileInfo
	var newestTime time.Time
	
	files, err := os.ReadDir(converterCmdDir)
	if err != nil {
		http.Error(w, "Не удалось прочитать директорию с результатом", http.StatusInternalServerError)
		return
	}
	for _, file := range files {
		if !file.IsDir() && strings.HasSuffix(file.Name(), ".html") {
			info, err := file.Info()
			if err != nil { continue }
			if info.ModTime().After(newestTime) {
				newestTime = info.ModTime()
				newestFile = info
			}
		}
	}
	if newestFile == nil {
		http.Error(w, "Утилита отработала, но не создала .html файл", http.StatusInternalServerError)
		return
	}
	
	sourcePath := filepath.Join(converterCmdDir, newestFile.Name())
	fileContent, err := os.ReadFile(sourcePath)
	if err != nil {
		http.Error(w, "Не удалось прочитать файл с результатом", http.StatusInternalServerError)
		return
	}

	wikiPath := filepath.Join(workDir, "tids", "wikis", dirName)
	if err := os.MkdirAll(wikiPath, os.ModePerm); err != nil {
		http.Error(w, "Не удалось создать целевую директорию", http.StatusInternalServerError)
		return
	}
	destinationPath := filepath.Join(wikiPath, dirName+".html")
	err = os.WriteFile(destinationPath, fileContent, 0644)
	if err != nil {
		http.Error(w, "Не удалось записать итоговый файл", http.StatusInternalServerError)
		return
	}

	os.Remove(sourcePath)

	log.Printf("Файл результата успешно скопирован в %s", destinationPath)
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{
		"message": fmt.Sprintf("Платформа '%s' успешно сконвертирована!", platform),
	})
}

func wikiFileHandler(w http.ResponseWriter, r *http.Request) { decodedPath, err := url.PathUnescape(r.URL.Path); if err != nil { http.Error(w, "Bad Request", http.StatusBadRequest); return }; pathSuffix := strings.TrimPrefix(decodedPath, "/wikis/"); filePath := filepath.Join("tids", "wikis", pathSuffix); if !strings.HasPrefix(filePath, filepath.Join("tids", "wikis")) { http.Error(w, "Forbidden", http.StatusForbidden); return }; http.ServeFile(w, r, filePath) }
func lifeCycleHandler(shutdownChan chan os.Signal) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost { http.Error(w, "Метод не разрешен", http.StatusMethodNotAllowed); return }; var req ClientIDRequest; if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, "Неверный запрос", http.StatusBadRequest); return }; if req.ID == "" { http.Error(w, "ID клиента не указан", http.StatusBadRequest); return }; path := r.URL.Path; mu.Lock(); defer mu.Unlock(); if path == "/api/connect" { activeClients[req.ID] = true; log.Printf("Клиент %s подключился. Всего активных клиентов: %d", req.ID, len(activeClients)) } else if path == "/api/disconnect" { delete(activeClients, req.ID); log.Printf("Клиент %s отключился. Всего активных клиентов: %d", req.ID, len(activeClients)); if len(activeClients) == 0 { log.Println("Последний клиент отключился. Инициирую остановку сервера..."); select { case shutdownChan <- syscall.SIGINT: default: } } }; w.WriteHeader(http.StatusOK) } }
func noCache(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate"); w.Header().Set("Pragma", "no-cache"); w.Header().Set("Expires", "0"); h.ServeHTTP(w, r) }) }

func main() {
	shutdownChan := make(chan os.Signal, 1)
	signal.Notify(shutdownChan, os.Interrupt, syscall.SIGTERM)

	os.MkdirAll(filepath.Join("tids", "wikis"), os.ModePerm)
	os.MkdirAll(filepath.Join("data", "image", "favicons"), os.ModePerm)
	os.MkdirAll(filepath.Join("data", "image", "screenshots"), os.ModePerm)

	http.HandleFunc("/api/delete-wiki", deleteWikiHandler)
	http.HandleFunc("/api/import-url", importUrlHandler)
	http.HandleFunc("/api/convert", convertHandler)

	lifeCycleMux := lifeCycleHandler(shutdownChan)
	http.HandleFunc("/api/connect", lifeCycleMux)
	http.HandleFunc("/api/disconnect", lifeCycleMux)

	http.HandleFunc("/api/wikis", func(w http.ResponseWriter, r *http.Request) {
		query := r.URL.Query().Get("q")
		wikis, err := findWikis(filepath.Join("tids", "wikis"), query)
		if err != nil {
			log.Printf("Ошибка при сканировании wikis: %v", err)
			http.Error(w, "Error", http.StatusInternalServerError)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(wikis)
	})

	http.HandleFunc("/wikis/", wikiFileHandler)

	staticHandler := noCache(http.FileServer(http.Dir("./frontend")))
	http.Handle("/", staticHandler)

	server := &http.Server{Addr: ":8080"}

	go func() {
		fmt.Println("Сервер запущен. Откройте в браузере http://localhost:8080")
		if err := server.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("Ошибка ListenAndServe: %v", err)
		}
	}()

	<-shutdownChan
	log.Println("Сервер останавливается...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := server.Shutdown(ctx); err != nil {
		log.Fatalf("Ошибка при остановке сервера: %v", err)
	}

	log.Println("Сервер успешно остановлен.")
	os.Exit(0)
}