main.go

package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"regexp"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gorilla/mux"
	"github.com/joho/godotenv"
	midtrans "github.com/midtrans/midtrans-go"
	"github.com/midtrans/midtrans-go/snap"
)

type Collection struct {
	Number      int    `json:"number"`
	Arab        string `json:"arab"`
	ID          string `json:"id"`
	Explanation string `json:"explanation,omitempty"`
}

type CollectionInfo struct {
	Name  string `json:"name"`
	Slug  string `json:"slug"`
	Total int    `json:"total"`
}

type HadithData struct {
	// Only keep collection info in memory (very small ~10KB)
	Info []CollectionInfo
	mu   sync.RWMutex
}

type Pagination struct {
	CurrentPage int
	TotalPages  int
	PerPage     int
	TotalItems  int
	HasNext     bool
	HasPrev     bool
}

type SearchResult struct {
	Collection string     `json:"collection"`
	Slug       string     `json:"slug"`
	Hadith     Collection `json:"hadith"`
	Context    string     `json:"context"`
	Score      int        `json:"score"` // For relevance scoring
}

type SearchFilters struct {
	Query       string      `json:"query"`
	Collections []string    `json:"collections"`
	Language    string      `json:"language"` // "ar", "id", "all"
	NumberRange NumberRange `json:"numberRange"`
	SortBy      string      `json:"sortBy"` // "relevance", "number", "collection"
}

type NumberRange struct {
	Min int `json:"min"`
	Max int `json:"max"`
}

type FilteredResults struct {
	Query       string
	Filters     SearchFilters
	Results     []SearchResult
	Pagination  Pagination
	TotalItems  int
	Collections []CollectionInfo
}

var (
	data              *HadithData
	tmpl              *template.Template
	geminiApiKey      string
	midtransServerKey string
	midtransClientKey string
	midtransEnvironment string
)

const (
	ItemsPerPage = 20
)

func init() {
	if err := godotenv.Load(); err != nil {
		log.Println("No .env file found")
	}
	geminiApiKey = os.Getenv("GEMINI_API_KEY")
	midtransServerKey = os.Getenv("MIDTRANS_SERVER_KEY")
	midtransClientKey = os.Getenv("MIDTRANS_CLIENT_KEY")
	midtransEnvironment = os.Getenv("MIDTRANS_ENVIRONMENT")

	// Initialize Midtrans Snap client
	if midtransServerKey != "" {
		var environment midtrans.EnvironmentType
		if midtransEnvironment == "production" {
			environment = midtrans.Production
		} else {
			environment = midtrans.Sandbox
		}
		midtrans.ServerKey = midtransServerKey
		midtrans.Environment = environment
	}
}

func loadData() {
	data = &HadithData{
		Info: []CollectionInfo{},
	}

	// Load only collection list (very small ~10KB)
	listData, err := ioutil.ReadFile("resource/list.json")
	if err != nil {
		log.Fatal("Error loading list.json:", err)
	}
	err = json.Unmarshal(listData, &data.Info)
	if err != nil {
		log.Fatal("Error parsing list.json:", err)
	}

	log.Printf("Loaded %d collection info (disk-based mode - very low memory usage)", len(data.Info))
}

// Load a single collection from disk on-demand
func loadCollection(slug string) ([]Collection, error) {
	filename := "resource/" + slug + ".json"
	collectionData, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, fmt.Errorf("error loading %s: %v", filename, err)
	}

	var collection []Collection
	err = json.Unmarshal(collectionData, &collection)
	if err != nil {
		return nil, fmt.Errorf("error parsing %s: %v", filename, err)
	}

	return collection, nil
}

// Get collection info by slug
func getCollectionInfo(slug string) *CollectionInfo {
	for _, info := range data.Info {
		if info.Slug == slug {
			return &info
		}
	}
	return nil
}

// Template functions
func add(a, b int) int {
	return a + b
}

func add1(a int) int {
	return a + 1
}

func subtract(a, b int) int {
	return a - b
}

func multiply(a, b int) int {
	return a * b
}

func formatHadith(s string) template.HTML {
	re := regexp.MustCompile(`\[(.*?)\]`)
	result := re.ReplaceAllString(s, "<strong>$1</strong>")
	return template.HTML(result)
}

func pageNumbers(current, total int) []int {
	var pages []int
	start := current - 2
	if start < 1 {
		start = 1
	}
	end := start + 4
	if end > total {
		end = total
		start = end - 4
		if start < 1 {
			start = 1
		}
	}

	for page := start; page <= end; page++ {
		pages = append(pages, page)
	}
	return pages
}

func formatRupiah(amount float64) string {
	return fmt.Sprintf("Rp %.0f", amount)
}

func calculatePercentage(current float64, target float64) float64 {
	if target <= 0 {
		return 0
	}
	percent := (current / target) * 100
	if percent > 100 {
		return 100
	}
	return percent
}

func safeHTML(s string) template.HTML {
	return template.HTML(s)
}

type SEOData struct {
	Title       string
	Description string
	Keywords    string
	OGImage     string
	OGUrl       string
	Canonical   string
}

type PageData struct {
	SEO        SEOData
	Data       interface{}
	Info       *CollectionInfo
	Hadith     *Collection
	PrevHadith *Collection
	NextHadith *Collection
	Collection string
	Pagination Pagination
}

func favoritesHandler(w http.ResponseWriter, r *http.Request) {
	seo := SEOData{
		Title:       "Hadits Favorit Saya - hadits.online",
		Description: "Daftar hadits pilihan yang Anda simpan untuk dipelajari lebih lanjut.",
		Keywords:    "hadits favorit, simpan hadits, belajar islam",
		OGUrl:       "https://hadits.online/favorites",
		Canonical:   "https://hadits.online/favorites",
	}

	pageData := PageData{
		SEO: seo,
	}

	tmpl := template.Must(template.ParseFiles("templates/favorites.html", "templates/components/navbar.html", "templates/components/footer.html"))
	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
	// Create a template with custom functions
	funcMap := template.FuncMap{
		"add":          add,
		"add1":         add1,
		"subtract":     subtract,
		"multiply":     multiply,
		"pageNumbers":  pageNumbers,
		"formatHadith": formatHadith,
	}

	seo := SEOData{
		Title:       "hadits.online - Pusat Belajar Hadits Terlengkap Bahasa Indonesia",
		Description: "Cari dan pelajari ribuan hadits shahih dari Bukhari, Muslim, Abu Daud, dan kitab lainnya dengan terjemahan Indonesia yang akurat.",
		Keywords:    "hadits online, hadits shahih, bukhari, muslim, terjemahan hadits, belajar islam",
		OGUrl:       "https://hadits.online/",
		Canonical:   "https://hadits.online/",
	}

	pageData := PageData{
		SEO:  seo,
		Data: data.Info,
	}

	tmpl := template.Must(template.New("index.html").Funcs(funcMap).ParseFiles("templates/index.html", "templates/components/navbar.html", "templates/components/footer.html"))
	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}

func collectionHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	slug := vars["slug"]

	// Get collection info
	info := getCollectionInfo(slug)
	if info == nil {
		http.Error(w, "Collection not found", http.StatusNotFound)
		return
	}

	// Load collection from disk on-demand
	collection, err := loadCollection(slug)
	if err != nil {
		http.Error(w, "Error loading collection: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// Get pagination parameters
	page := 1
	if pageStr := r.URL.Query().Get("page"); pageStr != "" {
		if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
			page = p
		}
	}

	// Calculate pagination
	totalItems := len(collection)
	totalPages := (totalItems + ItemsPerPage - 1) / ItemsPerPage
	startIndex := (page - 1) * ItemsPerPage
	endIndex := startIndex + ItemsPerPage

	if startIndex >= totalItems {
		startIndex = 0
		endIndex = ItemsPerPage
		page = 1
	}

	if endIndex > totalItems {
		endIndex = totalItems
	}

	paginatedHadiths := collection[startIndex:endIndex]

	pagination := Pagination{
		CurrentPage: page,
		TotalPages:  totalPages,
		PerPage:     ItemsPerPage,
		TotalItems:  totalItems,
		HasNext:     page < totalPages,
		HasPrev:     page > 1,
	}

	seo := SEOData{
		Title:       fmt.Sprintf("Koleksi Hadits %s - hadits.online", info.Name),
		Description: fmt.Sprintf("Daftar lengkap hadits dari kitab %s. Tersedia %d hadits dengan terjemahan Indonesia.", info.Name, info.Total),
		Keywords:    fmt.Sprintf("hadits %s, kitab %s, kumpulan hadits", info.Name, info.Name),
		OGUrl:       fmt.Sprintf("https://hadits.online/collection/%s", slug),
		Canonical:   fmt.Sprintf("https://hadits.online/collection/%s", slug),
	}

	pageData := PageData{
		SEO:        seo,
		Info:       info,
		Data:       paginatedHadiths,
		Collection: slug,
		Pagination: pagination,
	}

	// Create template with custom functions
	funcMap := template.FuncMap{
		"add":          add,
		"add1":         add1,
		"subtract":     subtract,
		"multiply":     multiply,
		"pageNumbers":  pageNumbers,
		"formatHadith": formatHadith,
	}

	tmpl := template.Must(template.New("collection.html").Funcs(funcMap).ParseFiles("templates/collection.html", "templates/components/navbar.html", "templates/components/footer.html"))
	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}

func hadithHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	slug := vars["slug"]
	numberStr := vars["number"]

	// Load collection from disk on-demand
	collection, err := loadCollection(slug)
	if err != nil {
		http.Error(w, "Error loading collection: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// Find hadith by number
	number, err := strconv.Atoi(numberStr)
	if err != nil {
		http.Error(w, "Invalid hadith number", http.StatusBadRequest)
		return
	}

	var hadith *Collection
	var hadithIndex int
	for i, h := range collection {
		if h.Number == number {
			hadith = &h
			hadithIndex = i
			break
		}
	}

	if hadith == nil {
		http.Error(w, "Hadith not found", http.StatusNotFound)
		return
	}

	// Get collection info
	info := getCollectionInfo(slug)
	if info == nil {
		http.Error(w, "Collection info not found", http.StatusNotFound)
		return
	}

	var prevHadith, nextHadith *Collection
	if hadithIndex > 0 {
		prevHadith = &collection[hadithIndex-1]
	}
	if hadithIndex < len(collection)-1 {
		nextHadith = &collection[hadithIndex+1]
	}

	description := hadith.ID
	if len(description) > 160 {
		description = description[:157] + "..."
	}

	seo := SEOData{
		Title:       fmt.Sprintf("Hadits %s No. %d - hadits.online", info.Name, hadith.Number),
		Description: description,
		Keywords:    fmt.Sprintf("hadits %s %d, %s no %d", info.Name, hadith.Number, info.Name, hadith.Number),
		OGUrl:       fmt.Sprintf("https://hadits.online/collection/%s/%d", slug, hadith.Number),
		Canonical:   fmt.Sprintf("https://hadits.online/collection/%s/%d", slug, hadith.Number),
	}

	pageData := PageData{
		SEO:        seo,
		Info:       info,
		Hadith:     hadith,
		PrevHadith: prevHadith,
		NextHadith: nextHadith,
	}

	// Create template with custom functions
	funcMap := template.FuncMap{
		"add":          add,
		"add1":         add1,
		"subtract":     subtract,
		"multiply":     multiply,
		"pageNumbers":  pageNumbers,
		"formatHadith": formatHadith,
	}

	tmpl := template.Must(template.New("hadith.html").Funcs(funcMap).ParseFiles("templates/hadith.html", "templates/components/navbar.html", "templates/components/footer.html"))
	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}

func searchHandler(w http.ResponseWriter, r *http.Request) {
	// Parse filters
	filters := parseSearchFilters(r)

	// Validate query
	if filters.Query == "" {
		http.Redirect(w, r, "/", http.StatusTemporaryRedirect)
		return
	}

	// Get pagination parameters
	page := 1
	if pageStr := r.URL.Query().Get("page"); pageStr != "" {
		if p, err := strconv.Atoi(pageStr); err == nil && p > 0 {
			page = p
		}
	}

	// Perform advanced search
	allResults := performAdvancedSearch(filters)
	totalItems := len(allResults)

	// Calculate pagination
	totalPages := (totalItems + ItemsPerPage - 1) / ItemsPerPage
	if page > totalPages && totalPages > 0 {
		page = totalPages
	}
	if page < 1 {
		page = 1
	}

	startIndex := (page - 1) * ItemsPerPage
	endIndex := startIndex + ItemsPerPage

	if startIndex < 0 {
		startIndex = 0
	}
	if startIndex > totalItems {
		startIndex = totalItems
	}
	if endIndex > totalItems {
		endIndex = totalItems
	}

	var paginatedResults []SearchResult
	if totalItems > 0 {
		paginatedResults = allResults[startIndex:endIndex]
	}

	pagination := Pagination{
		CurrentPage: page,
		TotalPages:  totalPages,
		PerPage:     ItemsPerPage,
		TotalItems:  totalItems,
		HasNext:     page < totalPages,
		HasPrev:     page > 1,
	}

	seo := SEOData{
		Title:       fmt.Sprintf("Hasil Pencarian: %s - hadits.online", filters.Query),
		Description: fmt.Sprintf("Temukan %d hadits terkait %s di hadits.online.", totalItems, filters.Query),
		Keywords:    fmt.Sprintf("cari hadits %s, hasil pencarian %s", filters.Query, filters.Query),
		OGUrl:       fmt.Sprintf("https://hadits.online/search?q=%s", filters.Query),
		Canonical:   fmt.Sprintf("https://hadits.online/search?q=%s", filters.Query),
	}

	pageData := struct {
		SEO         SEOData
		Query       string
		Filters     SearchFilters
		Results     []SearchResult
		Pagination  Pagination
		TotalItems  int
		Collections []CollectionInfo
	}{
		SEO:         seo,
		Query:       filters.Query,
		Filters:     filters,
		Results:     paginatedResults,
		Pagination:  pagination,
		TotalItems:  totalItems,
		Collections: data.Info,
	}

	// Create template with custom functions
	funcMap := template.FuncMap{
		"add":          add,
		"add1":         add1,
		"subtract":     subtract,
		"multiply":     multiply,
		"pageNumbers":  pageNumbers,
		"formatHadith": formatHadith,
		"urlEncode": func(s string) string {
			result := strings.ReplaceAll(s, " ", "+")
			result = strings.ReplaceAll(result, "&", "%26")
			result = strings.ReplaceAll(result, "=", "%3D")
			return result
		},
		"hasFilter": func(slice []string, item string) bool {
			for _, v := range slice {
				if v == item {
					return true
				}
			}
			return false
		},
		"buildFilterURL": func(query string, filters SearchFilters, page int) string {
			params := []string{}
			if query != "" {
				params = append(params, "q="+strings.ReplaceAll(query, " ", "+"))
			}
			if filters.Language != "" && filters.Language != "all" {
				params = append(params, "lang="+filters.Language)
			}
			if filters.SortBy != "" && filters.SortBy != "relevance" {
				params = append(params, "sort="+filters.SortBy)
			}
			if len(filters.Collections) > 0 {
				collections := strings.Join(filters.Collections, ",")
				params = append(params, "collections="+collections)
			}
			if filters.NumberRange.Min > 0 {
				params = append(params, fmt.Sprintf("min=%d", filters.NumberRange.Min))
			}
			if filters.NumberRange.Max > 0 {
				params = append(params, fmt.Sprintf("max=%d", filters.NumberRange.Max))
			}
			if page > 1 {
				params = append(params, fmt.Sprintf("page=%d", page))
			}

			if len(params) > 0 {
				return "/search?" + strings.Join(params, "&")
			}
			return "/search"
		},
	}

	tmpl := template.Must(template.New("search.html").Funcs(funcMap).ParseFiles("templates/search.html", "templates/components/navbar.html", "templates/components/footer.html"))
	if err := tmpl.Execute(w, pageData); err != nil {
		log.Printf("Template execution error in searchHandler: %v", err)
		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
	}
}

// Helper function to highlight search terms
func highlightText(text, query string) string {
	if query == "" {
		return text
	}

	// Simple highlighting - in production you'd want more sophisticated highlighting
	words := strings.Fields(strings.ToLower(query))
	result := text

	for _, word := range words {
		if len(word) > 2 { // Only highlight words longer than 2 characters
			// This is a simple case-insensitive replacement
			// In production, you'd want better HTML escaping and matching
			result = strings.ReplaceAll(result, word,
				"<mark class='bg-yellow-200 px-1 rounded'>"+word+"</mark>")
		}
	}

	return result
}

// Advanced filtering functions
func parseSearchFilters(r *http.Request) SearchFilters {
	filters := SearchFilters{
		Query:    strings.ToLower(strings.TrimSpace(r.URL.Query().Get("q"))),
		Language: r.URL.Query().Get("lang"),
		SortBy:   r.URL.Query().Get("sort"),
	}

	// Parse collections filter
	collectionsParam := r.URL.Query().Get("collections")
	if collectionsParam != "" {
		filters.Collections = strings.Split(collectionsParam, ",")
		// Clean up collection names
		for i, col := range filters.Collections {
			filters.Collections[i] = strings.TrimSpace(col)
		}
	}

	// Parse number range
	minStr := r.URL.Query().Get("min")
	maxStr := r.URL.Query().Get("max")
	if minStr != "" || maxStr != "" {
		filters.NumberRange = NumberRange{}
		if minStr != "" {
			if min, err := strconv.Atoi(minStr); err == nil {
				filters.NumberRange.Min = min
			}
		}
		if maxStr != "" {
			if max, err := strconv.Atoi(maxStr); err == nil {
				filters.NumberRange.Max = max
			}
		}
	}

	// Set defaults
	if filters.Language == "" {
		filters.Language = "all"
	}
	if filters.SortBy == "" {
		filters.SortBy = "relevance"
	}

	return filters
}

func calculateRelevanceScore(arabText, idText string, query string, queryWords []string) int {
	score := 0

	// Exact match gets highest score (only check once)
	if strings.Contains(arabText, query) || strings.Contains(idText, query) {
		score += 100
	}

	// Check for partial matches (optimized with pre-split words)
	for _, word := range queryWords {
		if len(word) > 2 {
			if strings.Contains(arabText, word) {
				score += 20
			}
			if strings.Contains(idText, word) {
				score += 15
			}
		}
	}

	// Boost score if query is in ID (Indonesian translation) - combined with above
	if strings.Contains(idText, query) {
		score += 30
	}

	// Boost score if query is in Arabic - combined with above
	if strings.Contains(arabText, query) {
		score += 25
	}

	return score
}

func matchesFilter(arabText, idText string, hadithNumber int, slug string, filters SearchFilters, query string, queryWords []string) bool {
	// Collection filter (early exit)
	if len(filters.Collections) > 0 {
		found := false
		for _, col := range filters.Collections {
			if strings.EqualFold(col, slug) {
				found = true
				break
			}
		}
		if !found {
			return false
		}
	}

	// Query match check - optimized with pre-lowered text and query
	queryMatched := false
	if filters.Language == "ar" {
		queryMatched = strings.Contains(arabText, query)
	} else if filters.Language == "id" {
		queryMatched = strings.Contains(idText, query)
	} else {
		// Default "all" or anything else: check both
		queryMatched = strings.Contains(arabText, query) || strings.Contains(idText, query)
	}

	// Also check individual words for better matching (word-level search)
	if !queryMatched && len(queryWords) > 0 {
		for _, word := range queryWords {
			if len(word) > 2 {
				if strings.Contains(arabText, word) || strings.Contains(idText, word) {
					queryMatched = true
					break
				}
			}
		}
	}

	if !queryMatched {
		return false
	}

	// Number range filter (early exit)
	if filters.NumberRange.Min > 0 && hadithNumber < filters.NumberRange.Min {
		return false
	}
	if filters.NumberRange.Max > 0 && hadithNumber > filters.NumberRange.Max {
		return false
	}

	return true
}

func sortResults(results []SearchResult, sortBy string) {
	switch sortBy {
	case "number":
		// Sort by hadith number within collections
		sort.Slice(results, func(i, j int) bool {
			if results[i].Slug != results[j].Slug {
				return results[i].Slug < results[j].Slug
			}
			return results[i].Hadith.Number < results[j].Hadith.Number
		})
	case "collection":
		// Sort by collection name
		sort.Slice(results, func(i, j int) bool {
			return results[i].Slug < results[j].Slug
		})
	default: // relevance
		sort.Slice(results, func(i, j int) bool {
			return results[i].Score > results[j].Score
		})
	}
}

// Disk-based search - loads collections from disk on-demand (minimal memory usage)
func performAdvancedSearch(filters SearchFilters) []SearchResult {
	lowerQuery := strings.ToLower(filters.Query)
	queryWords := strings.Fields(lowerQuery)

	// Pre-allocate results slice with memory limit
	maxResults := 500
	allResults := make([]SearchResult, 0, 100)

	data.mu.RLock()
	defer data.mu.RUnlock()

	// Get collections to search (based on filter)
	var collectionsToSearch []CollectionInfo
	if len(filters.Collections) > 0 {
		// Filter collections
		for _, col := range filters.Collections {
			for _, info := range data.Info {
				if strings.EqualFold(col, info.Slug) {
					collectionsToSearch = append(collectionsToSearch, info)
					break
				}
			}
		}
	} else {
		// Search all collections
		collectionsToSearch = data.Info
	}

	// Search each collection (disk-based)
	for _, info := range collectionsToSearch {
		// Load collection from disk on-demand
		collection, err := loadCollection(info.Slug)
		if err != nil {
			log.Printf("Error loading collection %s: %v", info.Slug, err)
			continue
		}

		// Search within this collection
		for _, hadith := range collection {
			// Limit results
			if len(allResults) >= maxResults {
				break
			}

			// Pre-lower texts
			lowerArab := strings.ToLower(hadith.Arab)
			lowerID := strings.ToLower(hadith.ID)

			// Check if matches filters
			if matchesFilter(lowerArab, lowerID, hadith.Number, info.Slug, filters, lowerQuery, queryWords) {
				// Calculate score
				score := calculateRelevanceScore(lowerArab, lowerID, lowerQuery, queryWords)

				// Get context
				context := hadith.ID
				if len(context) > 300 {
					context = context[:300] + "..."
				}

				allResults = append(allResults, SearchResult{
					Collection: info.Name,
					Slug:       info.Slug,
					Hadith:     hadith,
					Context:    context,
					Score:      score,
				})
			}
		}

		// Early exit if we have enough results
		if len(allResults) >= maxResults {
			break
		}
	}

	// Sort results
	if len(allResults) > 0 {
		sortResults(allResults, filters.SortBy)
	}

	return allResults
}

// Helper function to get page URL
func getPageURL(baseURL string, page int) string {
	if page == 1 {
		return baseURL
	}
	separator := "?"
	if strings.Contains(baseURL, "?") {
		separator = "&"
	}
	return baseURL + separator + "page=" + strconv.Itoa(page)
}

func robotsHandler(w http.ResponseWriter, r *http.Request) {
	content := "User-agent: *\nAllow: /\nSitemap: https://hadits.online/sitemap.xml"
	w.Header().Set("Content-Type", "text/plain")
	w.Write([]byte(content))
}

func sitemapHandler(w http.ResponseWriter, r *http.Request) {
	var sb strings.Builder
	sb.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
	sb.WriteString("<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n")

	// Home
	sb.WriteString("  <url>\n    <loc>https://hadits.online/</loc>\n    <priority>1.0</priority>\n  </url>\n")
	sb.WriteString("  <url>\n    <loc>https://hadits.online/donate</loc>\n    <priority>0.5</priority>\n  </url>\n")
	sb.WriteString("  <url>\n    <loc>https://hadits.online/faq</loc>\n    <priority>0.5</priority>\n  </url>\n")

	// Collections (disk-based - load each collection individually)
	data.mu.RLock()
	for _, info := range data.Info {
		sb.WriteString(fmt.Sprintf("  <url>\n    <loc>https://hadits.online/collection/%s</loc>\n    <priority>0.8</priority>\n  </url>\n", info.Slug))

		// Load collection for individual hadith URLs
		collection, err := loadCollection(info.Slug)
		if err != nil {
			log.Printf("Error loading collection %s for sitemap: %v", info.Slug, err)
			continue
		}

		// Individual Hadiths (limited to first 100 to keep sitemap small and fast)
		// You can increase this if needed, but for disk-based mode, limiting is better
		limit := 100
		for i, h := range collection {
			if i >= limit {
				break
			}
			sb.WriteString(fmt.Sprintf("  <url>\n    <loc>https://hadits.online/collection/%s/%d</loc>\n    <priority>0.6</priority>\n  </url>\n", info.Slug, h.Number))
		}
	}
	data.mu.RUnlock()

	sb.WriteString("</urlset>")
	w.Header().Set("Content-Type", "application/xml")
	w.Write([]byte(sb.String()))
}

func main() {
	log.Println("Loading hadith data...")
	loadData()
	log.Println("Data loaded successfully")

	r := mux.NewRouter()

	// Routes with better error handling
	r.HandleFunc("/", homeHandler)
	r.HandleFunc("/favorites", favoritesHandler)
	r.HandleFunc("/collection/{slug}", collectionHandler)
	r.HandleFunc("/collection/{slug}/{number}", hadithHandler)
	r.HandleFunc("/search", searchHandler)
	r.HandleFunc("/api/explain", explainHandler)
	r.HandleFunc("/donate", donateHandler)
	r.HandleFunc("/api/midtrans/token", midtransTokenHandler)
	r.HandleFunc("/faq", faqHandler)
	r.HandleFunc("/robots.txt", robotsHandler)
	r.HandleFunc("/sitemap.xml", sitemapHandler)
	r.HandleFunc("/manifest.json", func(w http.ResponseWriter, r *http.Request) {
		http.ServeFile(w, r, "static/manifest.json")
	})
	r.HandleFunc("/service-worker.js", func(w http.ResponseWriter, r *http.Request) {
		http.ServeFile(w, r, "static/service-worker.js")
	})

	// Serve static files
	r.PathPrefix("/static/").Handler(http.StripPrefix("/static/", http.FileServer(http.Dir("static/"))))

	// Serve index.html at root
	r.HandleFunc("/index.html", homeHandler)

	// Add 404 handler
	r.NotFoundHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNotFound)
		tmpl := template.Must(template.ParseFiles("templates/404.html", "templates/components/navbar.html", "templates/components/footer.html"))

		seo := SEOData{
			Title:       "Halaman Tidak Ditemukan - hadits.online",
			Description: "Maaf, halaman yang Anda cari tidak dapat ditemukan.",
		}

		tmpl.Execute(w, struct {
			SEO  SEOData
			Path string
		}{SEO: seo, Path: r.URL.Path})
	})

	log.Println("Server starting on :8082")
	log.Println("Access the application at: http://localhost:8082")
	log.Fatal(http.ListenAndServe(":8082", r))
}

type GeminiPart struct {
	Text string `json:"text"`
}

type GeminiContent struct {
	Parts []GeminiPart `json:"parts"`
}

type GeminiRequest struct {
	Contents          []GeminiContent `json:"contents"`
	SystemInstruction GeminiContent   `json:"system_instruction,omitempty"`
}

type GeminiResponse struct {
	Candidates []struct {
		Content GeminiContent `json:"content"`
	} `json:"candidates"`
}

func explainHandler(w http.ResponseWriter, r *http.Request) {
	if geminiApiKey == "" {
		http.Error(w, "AI configuration missing", http.StatusServiceUnavailable)
		return
	}

	slug := r.URL.Query().Get("slug")
	numberStr := r.URL.Query().Get("number")

	if slug == "" || numberStr == "" {
		http.Error(w, "Missing parameters", http.StatusBadRequest)
		return
	}

	number, _ := strconv.Atoi(numberStr)

	// Load collection from disk on-demand
	collection, err := loadCollection(slug)
	if err != nil {
		http.Error(w, "Error loading collection: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var hadith *Collection
	for i, h := range collection {
		if h.Number == number {
			hadith = &collection[i]
			break
		}
	}

	if hadith == nil {
		http.Error(w, "Hadith not found", http.StatusNotFound)
		return
	}

	// Check if explanation already exists in cache
	if hadith.Explanation != "" {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{
			"explanation": hadith.Explanation,
		})
		return
	}

	// Get collection name
	collectionName := slug
	info := getCollectionInfo(slug)
	if info != nil {
		collectionName = info.Name
	}

	systemPrompt := `Role: Anda adalah seorang Ahli Ilmu Hadis dan Syarah (Penjelas) Hadis Digital yang akurat, objektif, dan mendalam.

Task: Tugas Anda adalah membedah teks hadis yang diberikan pengguna ke dalam struktur penjelasan yang baku dan mudah dipahami.

Output Structure:
Setiap jawaban WAJIB mengikuti format berikut:

1. Disclaimer (WAJIB di posisi paling atas):
   - Gunakan format Blockquote atau Italic: "> ⚠️ Disclaimer: Respons ini dihasilkan oleh AI hanya sebagai bahan pertimbangan, diskusi, atau wawasan tambahan. Jawaban ini bukan merupakan fatwa hukum dan tidak bisa dijadikan rujukan utama dalam beragama. Silakan berkonsultasi dengan ulama atau ahli agama yang kredibel untuk keputusan hukum yang mengikat."

2. Identitas & Takhrij: 
   - Sebutkan perawi utama (Sahabat yang meriwayatkan).
   - Sebutkan derajat hadis (Sahih/Hasan/Dhaif) beserta sumber kitabnya (Misal: HR. Bukhari no. 123).

3. Makna Lughawi (Bahasa): 
   - Jelaskan istilah sulit atau kata kunci secara ringkas.

4. Asbabul Wurud (Konteks): 
   - Jelaskan latar belakang hadis atau konteks umum tema tersebut.

5. Istinbath (Pelajaran & Hukum): 
   - Berikan poin-poin ilmu, hukum, etika, atau hikmah yang terkandung.

6. Relevansi Kontemporer: 
   - Penerapan praktis dalam kehidupan modern.

7. Sumber Rujukan:
   - Sebutkan kitab Syarah yang digunakan (Contoh: Fathul Bari, Syarah An-Nawawi, dll).

Guiding Principles:
- Jika hadis berstatus Dhaif (lemah), berikan catatan tambahan setelah disclaimer.
- Tetap bersandar pada literatur klasik (Turats) dan pendapat ulama otoritatif.
- Gunakan Markdown untuk struktur yang rapi.`

	userPrompt := fmt.Sprintf("Kitab: %s\nNomor: %d \n\nArab:\n%s",
		collectionName, hadith.Number, hadith.Arab)

	geminiReq := GeminiRequest{
		Contents: []GeminiContent{
			{Parts: []GeminiPart{{Text: userPrompt}}},
		},
		SystemInstruction: GeminiContent{
			Parts: []GeminiPart{{Text: systemPrompt}},
		},
	}

	jsonData, _ := json.Marshal(geminiReq)
	url := fmt.Sprintf("https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent")
	req, _ := http.NewRequest("POST", url, strings.NewReader(string(jsonData)))
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("x-goog-api-key", geminiApiKey)

	client := &http.Client{Timeout: 3 * time.Minute}
	resp, err := client.Do(req)
	if err != nil {
		http.Error(w, "Error calling AI API", http.StatusInternalServerError)
		return
	}
	fmt.Println(resp)
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)
	var geminiResp GeminiResponse
	if err := json.Unmarshal(body, &geminiResp); err != nil {
		log.Printf("Gemini parsing error: %v, Body: %s", err, string(body))
		http.Error(w, "Error parsing AI response", http.StatusInternalServerError)
		return
	}

	if len(geminiResp.Candidates) == 0 || len(geminiResp.Candidates[0].Content.Parts) == 0 {
		http.Error(w, "No response from AI", http.StatusInternalServerError)
		return
	}

	explanation := geminiResp.Candidates[0].Content.Parts[0].Text

	// Save explanation to disk (disk-based approach)
	updatedCollection, err := loadCollection(slug)
	if err != nil {
		log.Printf("Error reloading collection for update: %v", err)
	} else {
		// Find and update the hadith
		for i := range updatedCollection {
			if updatedCollection[i].Number == number {
				updatedCollection[i].Explanation = explanation
				break
			}
		}

		// Save updated collection to disk
		filename := "resource/" + slug + ".json"
		jsonData, err := json.MarshalIndent(updatedCollection, "", "  ")
		if err != nil {
			log.Printf("Error marshaling collection %s for caching: %v", slug, err)
		} else {
			err = ioutil.WriteFile(filename, jsonData, 0644)
			if err != nil {
				log.Printf("Error writing cache to %s: %v", filename, err)
			}
		}
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{
		"explanation": explanation,
	})
}

// Donation page handler
func donateHandler(w http.ResponseWriter, r *http.Request) {
	seo := SEOData{
		Title:       "Donasi & Dukung Kami - hadits.online",
		Description: "Bantu kami menjaga keberlangsungan layanan Hadits.online agar tetap gratis bagi umat Islam.",
		Keywords:    "donasi islam, dukung dakwah digital, hadits online",
		OGUrl:       "https://hadits.online/donate",
		Canonical:   "https://hadits.online/donate",
	}

	pageData := struct {
		SEO         SEOData
		ClientKey   string
		Environment string
	}{
		SEO:         seo,
		ClientKey:   midtransClientKey,
		Environment: midtransEnvironment,
	}

	tmpl := template.Must(template.New("donate.html").Funcs(template.FuncMap{
		"add":                 add,
		"add1":                add1,
		"subtract":            subtract,
		"multiply":            multiply,
		"pageNumbers":         pageNumbers,
		"formatRupiah":        formatRupiah,
		"calculatePercentage": calculatePercentage,
		"safeHTML":            safeHTML,
	}).ParseFiles("templates/donate.html", "templates/components/navbar.html", "templates/components/footer.html"))

	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}

// Midtrans Snap token handler
func midtransTokenHandler(w http.ResponseWriter, r *http.Request) {
	if midtransServerKey == "" {
		http.Error(w, "Midtrans not configured", http.StatusServiceUnavailable)
		return
	}

	var reqBody struct {
		Amount   int    `json:"amount"`
		DonorName string `json:"donor_name"`
		DonorEmail string `json:"donor_email"`
		DonorPhone string `json:"donor_phone"`
	}

	if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	// Validate amount
	if reqBody.Amount < 10000 {
		http.Error(w, "Minimum donation amount is Rp 10.000", http.StatusBadRequest)
		return
	}

	// Generate unique order ID
	orderID := fmt.Sprintf("DONATION-%d-%d", time.Now().Unix(), reqBody.Amount)

	// Create Snap request
	req := &snap.Request{
		TransactionDetails: midtrans.TransactionDetails{
			OrderID:  orderID,
			GrossAmt: int64(reqBody.Amount),
		},
		CustomerDetail: &midtrans.CustomerDetails{
			FName: strings.Split(reqBody.DonorName, " ")[0],
			Email: reqBody.DonorEmail,
			Phone: reqBody.DonorPhone,
		},
		Items: &[]midtrans.ItemDetails{
			{
				ID:    "DONATION",
				Price: int64(reqBody.Amount),
				Qty:   1,
				Name:  "Donasi Hadits Online",
			},
		},
	}

	// Create Snap transaction
	token, err := snap.CreateTransactionToken(req)
	if err != nil {
		log.Printf("Error creating Midtrans transaction: %v", err)
		http.Error(w, "Failed to create transaction", http.StatusInternalServerError)
		return
	}

	response := map[string]string{
		"token":   token,
		"order_id": orderID,
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

// FAQ page handler
func faqHandler(w http.ResponseWriter, r *http.Request) {
	seo := SEOData{
		Title:       "Pertanyaan Umum (FAQ) - hadits.online",
		Description: "Jawaban atas pertanyaan yang sering diajukan mengenai penggunaan dan fitur Hadits.online.",
		Keywords:    "faq hadits online, bantuan hadits",
		OGUrl:       "https://hadits.online/faq",
		Canonical:   "https://hadits.online/faq",
	}

	pageData := PageData{
		SEO: seo,
	}

	tmpl := template.Must(template.New("faq.html").Funcs(template.FuncMap{
		"add":         add,
		"add1":        add1,
		"subtract":    subtract,
		"multiply":    multiply,
		"pageNumbers": pageNumbers,
	}).ParseFiles("templates/faq.html", "templates/components/navbar.html", "templates/components/footer.html"))

	if err := tmpl.Execute(w, pageData); err != nil {
		http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
	}
}