main.go

package main

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"math/rand"
	"net/http"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode"

	"github.com/asim/reminder/api"
	"github.com/asim/reminder/app"
	"github.com/asim/reminder/daily"
	"github.com/asim/reminder/hadith"
	"github.com/asim/reminder/names"
	"github.com/asim/reminder/quran"
	"github.com/asim/reminder/search"
	"github.com/google/uuid"
)

var (
	IndexFlag  = flag.Bool("index", false, "Index data for search. Stored at $HOME/reminder.idx")
	ExportFlag = flag.Bool("export", false, "Export the index data to $HOME/reminder.idx.gob.gz")
	ImportFlag = flag.Bool("import", false, "Import the index data from $HOME/reminder.idx.gob.gz")
	ServerFlag = flag.Bool("serve", false, "Run the server")
	EnvFlag    = flag.String("env", "dev", "Set the environment")
	WebFlag    = flag.Bool("web", false, "Without this flag, the lite version will be served")
)

var mtx sync.RWMutex
var history = map[string][]string{}
var dailyName, dailyVerse, dailyHadith, dailyMessage string
var links = map[string]string{}
var dailyUpdated = time.Time{}
var reminderDir = api.ReminderDir
var lastPushDateFile = api.ReminderPath("last_push_date.txt")
var lastPushDate = loadLastPushDate()
var dailyIndex = loadDailyIndex()

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func isCapital(s string) bool {
	if len(s) == 0 {
		return false // An empty string doesn't have a capitalized first letter
	}

	firstChar := []rune(s)[0] // Convert string to slice of runes to handle Unicode characters

	// Check if the first character is a letter
	if !unicode.IsLetter(firstChar) {
		return false // If it's not a letter, it can't be capitalized
	}

	return unicode.IsUpper(firstChar)
}

func isAPIClient(r *http.Request) bool {
	userAgent := r.Header.Get("User-Agent")
	accept := r.Header.Get("Accept")

	return strings.Contains(userAgent, "Wget") ||
		strings.Contains(userAgent, "curl") ||
		strings.Contains(userAgent, "Go-http-client") ||
		strings.Contains(userAgent, "python-requests") ||
		(accept != "" && !strings.Contains(accept, "text/html") && !strings.Contains(accept, "*/*"))
}

func registerLiteRoutes(q *quran.Quran, n *names.Names, b *hadith.Collection, a *api.Api) {
	http.HandleFunc("/home", func(w http.ResponseWriter, r *http.Request) {
		mtx.RLock()
		verseLink := links["verse"]
		hadithLink := links["hadith"]
		nameLink := links["name"]
		verse := dailyVerse
		hadith := dailyHadith
		name := dailyName
		mtx.RUnlock()

		// Populate Index template with actual data
		indexContent := strings.ReplaceAll(app.Index, "{verse_link}", verseLink)
		indexContent = strings.ReplaceAll(indexContent, "{verse_text}", verse)
		indexContent = strings.ReplaceAll(indexContent, "{hadith_link}", hadithLink)
		indexContent = strings.ReplaceAll(indexContent, "{hadith_text}", hadith)
		indexContent = strings.ReplaceAll(indexContent, "{name_link}", nameLink)
		indexContent = strings.ReplaceAll(indexContent, "{name_text}", name)

		if isAPIClient(r) {
			w.Write([]byte(app.RenderSimpleHTML("Home", "Quran, hadith, and more as an app and API", indexContent)))
		} else {
			w.Write([]byte(app.RenderHTML("Home", "Quran, hadith, and more as an app and API", indexContent)))
		}
	})

	http.HandleFunc("/bookmarks", func(w http.ResponseWriter, r *http.Request) {
		bookmarksContent := `
<div id="quran-bookmarks" class="mb-8">
  <h2 class="text-2xl font-semibold mb-4">Quran</h2>
  <div id="quran-list" class="space-y-3"></div>
</div>

<div id="hadith-bookmarks" class="mb-8">
  <h2 class="text-2xl font-semibold mb-4">Hadith</h2>
  <div id="hadith-list" class="space-y-3"></div>
</div>

<div id="names-bookmarks" class="mb-8">
  <h2 class="text-2xl font-semibold mb-4">Names</h2>
  <div id="names-list" class="space-y-3"></div>
</div>

<script>
  function loadBookmarks() {
    const bookmarks = JSON.parse(localStorage.getItem('reminder_bookmarks') || '{"quran":{},"hadith":{},"names":{}}');
    
    // Quran bookmarks
    const quranList = document.getElementById('quran-list');
    const quranKeys = Object.keys(bookmarks.quran || {});
    if (quranKeys.length > 0) {
      quranList.innerHTML = quranKeys.map(key => {
        const bookmark = bookmarks.quran[key];
        return ` + "`" + `
        <div class="flex items-center justify-between p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors">
          <a href="${bookmark.url}" class="flex-grow text-blue-600 hover:text-blue-800">${bookmark.label}</a>
          <button onclick="removeBookmark('quran', '${key}')" class="px-3 py-1 bg-red-500 text-white rounded hover:bg-red-600 transition-colors text-sm">Remove</button>
        </div>
      ` + "`" + `;
      }).join('');
    } else {
      quranList.innerHTML = '<p class="text-gray-500">No bookmarks yet</p>';
    }
    
    // Hadith bookmarks
    const hadithList = document.getElementById('hadith-list');
    const hadithKeys = Object.keys(bookmarks.hadith || {});
    if (hadithKeys.length > 0) {
      hadithList.innerHTML = hadithKeys.map(key => {
        const bookmark = bookmarks.hadith[key];
        return ` + "`" + `
        <div class="flex items-center justify-between p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors">
          <a href="${bookmark.url}" class="flex-grow text-blue-600 hover:text-blue-800">${bookmark.label}</a>
          <button onclick="removeBookmark('hadith', '${key}')" class="px-3 py-1 bg-red-500 text-white rounded hover:bg-red-600 transition-colors text-sm">Remove</button>
        </div>
      ` + "`" + `;
      }).join('');
    } else {
      hadithList.innerHTML = '<p class="text-gray-500">No bookmarks yet</p>';
    }
    
    // Names bookmarks
    const namesList = document.getElementById('names-list');
    const namesKeys = Object.keys(bookmarks.names || {});
    if (namesKeys.length > 0) {
      namesList.innerHTML = namesKeys.map(key => {
        const bookmark = bookmarks.names[key];
        return ` + "`" + `
        <div class="flex items-center justify-between p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors">
          <a href="${bookmark.url}" class="flex-grow text-blue-600 hover:text-blue-800">${bookmark.label}</a>
          <button onclick="removeBookmark('names', '${key}')" class="px-3 py-1 bg-red-500 text-white rounded hover:bg-red-600 transition-colors text-sm">Remove</button>
        </div>
      ` + "`" + `;
      }).join('');
    } else {
      namesList.innerHTML = '<p class="text-gray-500">No bookmarks yet</p>';
    }
  }
  
  function removeBookmark(type, key) {
    const bookmarks = JSON.parse(localStorage.getItem('reminder_bookmarks') || '{"quran":{},"hadith":{},"names":{}}');
    if (bookmarks[type] && bookmarks[type][key]) {
      delete bookmarks[type][key];
      localStorage.setItem('reminder_bookmarks', JSON.stringify(bookmarks));
      loadBookmarks();
    }
  }
  
  loadBookmarks();
</script>
`

		w.Write([]byte(app.RenderHTML("Bookmarks", "", bookmarksContent)))
	})

	http.HandleFunc("/quran", func(w http.ResponseWriter, r *http.Request) {
		content := q.TOC()
		if isAPIClient(r) {
			qhtml := app.RenderSimpleHTML("Quran", quran.Description, content)
			w.Write([]byte(qhtml))
		} else {
			qhtml := app.RenderHTML("Quran", quran.Description, content)
			w.Write([]byte(qhtml))
		}
	})

	http.HandleFunc("/hadith", func(w http.ResponseWriter, r *http.Request) {
		content := b.TOC()
		if isAPIClient(r) {
			qhtml := app.RenderSimpleHTML("Hadith", hadith.Description, content)
			w.Write([]byte(qhtml))
		} else {
			qhtml := app.RenderHTML("Hadith", hadith.Description, content)
			w.Write([]byte(qhtml))
		}
	})

	http.HandleFunc("/names", func(w http.ResponseWriter, r *http.Request) {
		content := n.TOC()
		if isAPIClient(r) {
			qhtml := app.RenderSimpleHTML("Names", names.Description, content)
			w.Write([]byte(qhtml))
		} else {
			qhtml := app.RenderHTML("Names", names.Description, content)
			w.Write([]byte(qhtml))
		}
	})

	http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
		content := a.HTML(app.RenderString)
		w.Write([]byte(app.RenderHTML("API", "", content)))
	})

	http.HandleFunc("/daily", func(w http.ResponseWriter, r *http.Request) {
		template := `
<h3 class="text-lg font-semibold mt-6 mb-2">Verse</h3>
<a href="%s" class="block p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors mb-4">%s</a>
<h3 class="text-lg font-semibold mt-6 mb-2">Hadith</h3>
<a href="%s" class="block p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors mb-4">%s</a>
<h3 class="text-lg font-semibold mt-6 mb-2">Name</h3>
<a href="%s" class="block p-4 bg-white border border-gray-200 rounded-lg hover:border-gray-400 transition-colors mb-4">%s</a>
<p class="text-sm text-gray-500 mt-4">Updated %s</p>
`
		mtx.RLock()
		verseLink := links["verse"]
		hadithLink := links["hadith"]
		nameLink := links["name"]

		data := fmt.Sprintf(template, verseLink, dailyVerse, hadithLink, dailyHadith, nameLink, dailyName, dailyUpdated.Format(time.RFC3339))
		mtx.RUnlock()

		html := app.RenderHTML("Daily Reminder", "Daily reminder from the quran, hadith and names of Allah", data)
		w.Write([]byte(html))
	})

	http.HandleFunc("/quran/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		if len(id) == 0 {
			return
		}

		ch, _ := strconv.Atoi(id)

		if ch < 1 || ch > 114 {
			return
		}

		head := fmt.Sprintf("%d | Quran", ch)
		content := q.Get(ch).HTML()

		qhtml := app.RenderHTML(head, "", content)
		w.Write([]byte(qhtml))
	})

	http.HandleFunc("/quran/{id}/{ver}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		if len(id) == 0 {
			return
		}

		ver := r.PathValue("ver")
		if len(ver) == 0 {
			return
		}

		ch, _ := strconv.Atoi(id)
		ve, _ := strconv.Atoi(ver)

		if ch < 1 || ch > 114 {
			return
		}

		cc := q.Get(ch)

		if ve < 1 || ve > len(cc.Verses) {
			return
		}

		vv := cc.Verses[ve-1]

		head := fmt.Sprintf("%d:%d | Quran", ch, ve)
		vhtml := app.RenderHTML(head, "", vv.HTML())

		w.Write([]byte(vhtml))
	})

	http.HandleFunc("/names/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		if len(id) == 0 {
			return
		}

		name, _ := strconv.Atoi(id)

		if name < 1 || name > len(*n) {
			return
		}

		head := fmt.Sprintf("%d | Names", name)
		content := n.Get(name).HTML()

		qhtml := app.RenderHTML(head, "", content)
		w.Write([]byte(qhtml))
	})

	http.HandleFunc("/hadith/{book}", func(w http.ResponseWriter, r *http.Request) {
		book := r.PathValue("book")
		if len(book) == 0 {
			return
		}

		ch, _ := strconv.Atoi(book)

		if ch < 1 || ch > len(b.Books) {
			return
		}

		head := fmt.Sprintf("%d | Hadith", ch)
		content := b.Get(ch).HTML()

		qhtml := app.RenderHTML(head, "", content)
		w.Write([]byte(qhtml))
	})

	http.HandleFunc("/search", func(w http.ResponseWriter, r *http.Request) {
		shtml := app.RenderHTML("Search", "", app.SearchTemplate)
		w.Write([]byte(shtml))
	})

	http.HandleFunc("/islam", func(w http.ResponseWriter, r *http.Request) {
		html := app.Get("islam.html")
		page := app.RenderHTML("Islam", "An overview of Islam", html)
		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		w.Write([]byte(page))
	})

	// Serve static files (bookmarks.js, manifest, etc.)
	staticFiles := []string{"bookmarks.js", "reminder.js", "manifest.webmanifest", "arabic.otf", "reminder.png", "icon-192.png", "icon-96.png"}
	for _, file := range staticFiles {
		fileName := file
		http.HandleFunc("/"+fileName, func(w http.ResponseWriter, r *http.Request) {
			content := app.Get(fileName)
			if strings.HasSuffix(fileName, ".js") {
				w.Header().Set("Content-Type", "application/javascript")
				w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
			} else if strings.HasSuffix(fileName, ".json") || strings.HasSuffix(fileName, ".webmanifest") {
				w.Header().Set("Content-Type", "application/json")
				w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
			} else if strings.HasSuffix(fileName, ".otf") {
				w.Header().Set("Content-Type", "font/otf")
				w.Header().Set("Cache-Control", "public, max-age=31536000")
			} else if strings.HasSuffix(fileName, ".png") {
				w.Header().Set("Content-Type", "image/png")
				w.Header().Set("Cache-Control", "public, max-age=31536000")
			}
			w.Write([]byte(content))
		})
	}

	// Root route - redirect to /home
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		// Only handle exact "/" path, let other routes handle themselves
		if r.URL.Path == "/" {
			http.Redirect(w, r, "/home", http.StatusFound)
			return
		}
		// For other paths, return 404 (no other handler matched)
		http.NotFound(w, r)
	})
}

func loadLastPushDate() string {
	fmt.Println("Load last pushdate")
	b, err := os.ReadFile(lastPushDateFile)
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(b))
}

func saveLastPushDate(date string) {
	_ = os.MkdirAll(reminderDir, 0700)
	_ = os.WriteFile(lastPushDateFile, []byte(date), 0644)
}

// On startup, load daily index
func loadDailyIndex() map[string]interface{} {
	fmt.Println("Load daily index")
	dailyFile := api.ReminderPath("daily.json")
	var idx map[string]interface{}
	if b, err := os.ReadFile(dailyFile); err == nil {
		json.Unmarshal(b, &idx)
	}
	if idx == nil {
		idx = make(map[string]interface{})
	}
	return idx
}

func saveDaily(date string, data map[string]interface{}) {
	// Save to daily.json
	dailyFile := api.ReminderPath("daily.json")
	var allDaily map[string]interface{}
	if b, err := os.ReadFile(dailyFile); err == nil {
		json.Unmarshal(b, &allDaily)
	}
	if allDaily == nil {
		allDaily = make(map[string]interface{})
	}
	allDaily[date] = data
	b, _ := json.MarshalIndent(allDaily, "", "  ")
	_ = os.MkdirAll(api.ReminderDir, 0700)
	_ = os.WriteFile(dailyFile, b, 0644)
	dailyIndex = allDaily // update in-memory index
}

func saveHourlyReminder(date, timestamp string, data map[string]interface{}) {
	// Save to hourly reminders file
	hourlyFile := api.ReminderPath(fmt.Sprintf("hourly_%s.json", date))
	var hourlyReminders []interface{}
	if b, err := os.ReadFile(hourlyFile); err == nil {
		json.Unmarshal(b, &hourlyReminders)
	}
	if hourlyReminders == nil {
		hourlyReminders = make([]interface{}, 0)
	}
	hourlyReminders = append(hourlyReminders, data)
	b, _ := json.MarshalIndent(hourlyReminders, "", "  ")
	_ = os.MkdirAll(api.ReminderDir, 0700)
	_ = os.WriteFile(hourlyFile, b, 0644)
}

func loadHourlyReminders(date string) []interface{} {
	hourlyFile := api.ReminderPath(fmt.Sprintf("hourly_%s.json", date))
	var hourlyReminders []interface{}
	if b, err := os.ReadFile(hourlyFile); err == nil {
		json.Unmarshal(b, &hourlyReminders)
	}
	return hourlyReminders
}

// generateMessage generates an LLM-based message using the verse, hadith, and name
// The askLLM function panics on errors, which is why we use panic recovery here.
func generateMessage(ctx context.Context, verse, hadith, name string) (message string) {
	// Fallback message in case LLM fails
	defaultMessage := "In the Name of Allah—the Most Beneficent, Most Merciful"
	message = defaultMessage // Set default in case of panic

	// Build context for the LLM
	contexts := []string{
		fmt.Sprintf("Verse from the Quran: %s", verse),
		fmt.Sprintf("Hadith: %s", hadith),
		fmt.Sprintf("Name of Allah: %s", name),
	}

	// Create a question that asks the LLM to generate a beneficial message
	question := "Based on the provided Quranic verse, Hadith, and name of Allah, generate a short, beneficial, and factual message (2-3 sentences) that provides spiritual guidance and reflection for the reader."

	// Use the LLM to generate the message
	// Wrap in a recover to handle panics from askLLM (which panics on errors)
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("Failed to generate contextual message via LLM: %v\n", r)
			message = defaultMessage // Ensure we return default on panic
		}
	}()

	llmMessage := askLLM(ctx, contexts, question)

	// If message is not empty, use it
	if len(strings.TrimSpace(llmMessage)) > 0 {
		message = llmMessage
	}

	return message
}

func main() {
	fmt.Println("New rand source")
	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))

	flag.Parse()

	// Load push subscriptions
	fmt.Println("Loading subscriptions")
	_ = api.LoadPushSubscriptions()

	// Load or generate VAPID keys
	fmt.Println("Loading VAPID keys")
	_ = api.LoadOrGenerateVAPIDKeys()

	// create a new indexa
	fmt.Println("Generating index")
	idx := search.New("reminder", false)

	// async load the index
	go func() {
		// Load the pre-existing data
		fmt.Println("Loading index")
		if err := idx.Load(); err != nil {
			fmt.Println(err)
		}
		fmt.Println("Loaded index")
	}()

	// load data
	fmt.Println("Initialising data")
	q := quran.Load()
	fmt.Println("Loaded Quran")
	n := names.Load()
	fmt.Println("Loaded Names")
	b := hadith.Load()
	fmt.Println("Loaded Hadith")
	a := api.Load()
	fmt.Println("Loaded API")

	// generate json
	qjson := q.JSON()
	njson := n.JSON()
	hjson := b.JSON()

	// index the quran in english
	indexed := make(chan bool, 1)

	if *IndexFlag {
		// create a separate index that's persisted
		// this is located in $HOME/reminder.idx
		// it will need to be exported afterwards
		sidx := search.New("reminder", true)

		fmt.Println("Indexing data")
		go func() {
			indexQuran(sidx, q)
			indexNames(sidx, n)
			indexHadith(sidx, b)
			indexTafsir(sidx, q)
			// done
			close(indexed)
		}()
	} else {
		close(indexed)
	}

	if *ExportFlag {
		fmt.Println("Exporting index")
		if err := idx.Export(); err != nil {
			fmt.Println(err)
		}
		return
	}

	if *ImportFlag {
		fmt.Println("Importing index")
		if err := idx.Import(); err != nil {
			fmt.Println(err)
		}
	}

	if *WebFlag {
		fmt.Println("Registering web handler")

		// Register TOC handlers for API clients only
		http.HandleFunc("/quran", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				content := q.TOC()
				qhtml := app.RenderSimpleHTML("Quran", quran.Description, content)
				w.Write([]byte(qhtml))
			} else {
				// Let SPA handle it
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		http.HandleFunc("/hadith", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				content := b.TOC()
				hhtml := app.RenderSimpleHTML("Hadith", hadith.Description, content)
				w.Write([]byte(hhtml))
			} else {
				// Let SPA handle it
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		http.HandleFunc("/names", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				content := n.TOC()
				nhtml := app.RenderSimpleHTML("Names", names.Description, content)
				w.Write([]byte(nhtml))
			} else {
				// Let SPA handle it
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		// Create smart handlers that serve lite content for API clients, SPA for browsers
		http.HandleFunc("/quran/{id}", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				// Serve server-rendered HTML
				id := r.PathValue("id")
				if len(id) == 0 {
					return
				}
				ch, _ := strconv.Atoi(id)
				if ch < 1 || ch > 114 {
					return
				}
				head := fmt.Sprintf("%d | Quran", ch)
				qhtml := app.RenderSimpleHTML(head, "", q.Get(ch).HTML())
				w.Write([]byte(qhtml))
			} else {
				// Serve SPA
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		http.HandleFunc("/hadith/{book}", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				book := r.PathValue("book")
				if len(book) == 0 {
					return
				}
				ch, _ := strconv.Atoi(book)
				if ch < 1 || ch > len(b.Books) {
					return
				}
				head := fmt.Sprintf("%d | Hadith", ch)
				qhtml := app.RenderSimpleHTML(head, "", b.Get(ch).HTML())
				w.Write([]byte(qhtml))
			} else {
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		http.HandleFunc("/names/{id}", func(w http.ResponseWriter, r *http.Request) {
			if isAPIClient(r) {
				id := r.PathValue("id")
				if len(id) == 0 {
					return
				}
				name, _ := strconv.Atoi(id)
				if name < 1 || name > len(*n) {
					return
				}
				head := fmt.Sprintf("%d | Names", name)
				qhtml := app.RenderSimpleHTML(head, "", n.Get(name).HTML())
				w.Write([]byte(qhtml))
			} else {
				// Serve SPA
				app.ServeWeb().ServeHTTP(w, r)
			}
		})

		// Everything else goes to SPA
		http.Handle("/", app.ServeWeb())
	} else {
		fmt.Println("Registering lite handler")
		registerLiteRoutes(q, n, b, a)
	}

	http.HandleFunc("/api/quran", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(qjson))
	})

	http.HandleFunc("/api/quran/{chapter}", func(w http.ResponseWriter, r *http.Request) {
		ch := r.PathValue("chapter")
		if len(ch) == 0 {
			w.WriteHeader(http.StatusNotFound)
			w.Write([]byte("{}"))
			return
		}

		chapter, _ := strconv.Atoi(ch)
		if chapter < 1 || chapter > 114 {
			w.WriteHeader(http.StatusNotFound)
			w.Write([]byte("{}"))
			return
		}

		b := q.Get(chapter).JSON()
		w.Write(b)
	})

	http.HandleFunc("/api/quran/chapters", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		b, _ := json.Marshal(q.Index().Chapters)
		w.Write(b)
	})

	http.HandleFunc("/api/quran/{chapter}/{verse}", func(w http.ResponseWriter, r *http.Request) {
		ch := r.PathValue("chapter")
		if len(ch) == 0 {
			return
		}

		chapter, _ := strconv.Atoi(ch)
		if chapter < 1 || chapter > 114 {
			return
		}

		ve := r.PathValue("verse")
		if len(ch) == 0 {
			return
		}

		cc := q.Get(chapter)

		verse, _ := strconv.Atoi(ve)
		if verse < 1 || verse > len(cc.Verses) {
			return
		}

		vee := cc.Verses[verse-1]
		b := vee.JSON()

		w.Write(b)
	})

	http.HandleFunc("/api/daily", func(w http.ResponseWriter, r *http.Request) {
		// GET: today's archived daily (saved at midnight UTC)
		today := time.Now().UTC().Format("2006-01-02")

		mtx.RLock()
		var resp interface{}
		if entry, ok := dailyIndex[today]; ok {
			resp = entry
		} else {
			// If today's archived daily doesn't exist yet, return the hourly updated content
			message := "In the Name of Allah—the Most Beneficent, Most Merciful"
			resp = map[string]interface{}{
				"name":    dailyName,
				"hadith":  dailyHadith,
				"verse":   dailyVerse,
				"links":   links,
				"updated": dailyUpdated.Format(time.RFC3339),
				"message": message,
				"hijri":   daily.Date().Display,
				"date":    today,
			}
		}
		mtx.RUnlock()

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

	// Add /api/latest endpoint for the hourly updated reminder
	http.HandleFunc("/api/latest", func(w http.ResponseWriter, r *http.Request) {
		mtx.RLock()
		verse := dailyVerse
		hadith := dailyHadith
		name := dailyName
		message := dailyMessage
		updated := dailyUpdated
		currentLinks := links
		mtx.RUnlock()

		resp := map[string]interface{}{
			"name":    name,
			"hadith":  hadith,
			"verse":   verse,
			"links":   currentLinks,
			"updated": updated.Format(time.RFC3339),
			"message": message,
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(resp)
	})

	http.HandleFunc("/api/daily/{date}", func(w http.ResponseWriter, r *http.Request) {
		date := r.PathValue("date")
		if len(date) == 0 {
			date = time.Now().Format("2006-01-02")
		}

		mtx.RLock()

		var resp interface{}
		if entry, ok := dailyIndex[date]; ok {
			resp = entry
		} else {
			w.WriteHeader(http.StatusNotFound)
			w.Write([]byte(`{"error":"Not found"}`))
			mtx.RUnlock()
			return
		}

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

	// Add daily index API endpoint
	http.HandleFunc("/api/daily/index", func(w http.ResponseWriter, r *http.Request) {
		mtx.RLock()
		b, _ := json.MarshalIndent(dailyIndex, "", "  ")
		mtx.RUnlock()
		w.Header().Set("Content-Type", "application/json")
		w.Write(b)
	})

	// RSS feed for daily content
	http.HandleFunc("/rss", func(w http.ResponseWriter, r *http.Request) {
		mtx.RLock()
		defer mtx.RUnlock()

		w.Header().Set("Content-Type", "application/rss+xml; charset=utf-8")

		// Get all dates and sort them
		var dates []string
		for date := range dailyIndex {
			if date == "latest" {
				continue
			}
			dates = append(dates, date)
		}

		// Sort dates in descending order (newest first)
		for i := 0; i < len(dates); i++ {
			for j := i + 1; j < len(dates); j++ {
				if dates[i] < dates[j] {
					dates[i], dates[j] = dates[j], dates[i]
				}
			}
		}

		// Start RSS feed
		fmt.Fprintf(w, `<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Daily Reminder</title>
    <link>https://reminder.dev</link>
    <description>Daily reminders from the Quran, Hadith, and Names of Allah</description>
    <language>en-us</language>
    <lastBuildDate>%s</lastBuildDate>
    <atom:link href="https://reminder.dev/rss" rel="self" type="application/rss+xml" />
`, time.Now().Format(time.RFC1123Z))

		// Add items for each date (limit to most recent 30 days)
		maxDays := 30
		if len(dates) < maxDays {
			maxDays = len(dates)
		}

		for i := 0; i < maxDays; i++ {
			date := dates[i]

			// Parse date for pubDate base
			basePubDate := date
			if t, err := time.Parse("2006-01-02", date); err == nil {
				basePubDate = t.Format(time.RFC1123Z)
			}

			// First, add hourly reminders for this date (most recent first)
			hourlyReminders := loadHourlyReminders(date)

			// Process each hourly reminder in reverse order (newest first)
			for i := len(hourlyReminders) - 1; i >= 0; i-- {
				reminderData := hourlyReminders[i]
				reminder, ok := reminderData.(map[string]interface{})
				if !ok {
					continue
				}

				// Get timestamp for pubDate
				pubDate := basePubDate
				if ts, ok := reminder["timestamp"].(string); ok {
					if t, err := time.Parse(time.RFC3339, ts); err == nil {
						pubDate = t.Format(time.RFC1123Z)
					}
				}

				// Extract verse metadata
				if verseMeta, ok := reminder["verse_meta"].(map[string]interface{}); ok {
					chapterName, _ := verseMeta["chapter_name"].(string)
					chapter, _ := verseMeta["chapter"].(float64)
					verseStart, _ := verseMeta["verse_start"].(float64)
					verseEnd, _ := verseMeta["verse_end"].(float64)
					text, _ := verseMeta["text"].(string)

					verseTitle := ""
					if verseStart == verseEnd {
						verseTitle = fmt.Sprintf("%s %d:%d", chapterName, int(chapter), int(verseStart))
					} else {
						verseTitle = fmt.Sprintf("%s %d:%d-%d", chapterName, int(chapter), int(verseStart), int(verseEnd))
					}

					verseLink := fmt.Sprintf("https://reminder.dev/quran/%d#%d", int(chapter), int(verseStart))

					fmt.Fprintf(w, `    <item>
      <title>%s</title>
      <link>%s</link>
      <guid>%s</guid>
      <pubDate>%s</pubDate>
      <description><![CDATA[%s]]></description>
    </item>
`, verseTitle, verseLink, verseLink, pubDate, text)
				}

				// Extract hadith metadata
				if hadithMeta, ok := reminder["hadith_meta"].(map[string]interface{}); ok {
					bookName, _ := hadithMeta["book_name"].(string)
					book, _ := hadithMeta["book"].(float64)
					info, _ := hadithMeta["info"].(string)
					text, _ := hadithMeta["text"].(string)

					// Get number as string
					number := "1"
					if num, ok := hadithMeta["number"].(string); ok {
						number = num
					}

					hadithTitle := fmt.Sprintf("%s - %s", bookName, info)
					hadithLink := fmt.Sprintf("https://reminder.dev/hadith/%d#%s", int(book), number)

					fmt.Fprintf(w, `    <item>
      <title>%s</title>
      <link>%s</link>
      <guid>%s</guid>
      <pubDate>%s</pubDate>
      <description><![CDATA[%s]]></description>
    </item>
`, hadithTitle, hadithLink, hadithLink, pubDate, text)
				}

				// Extract name metadata
				if nameMeta, ok := reminder["name_meta"].(map[string]interface{}); ok {
					number, _ := nameMeta["number"].(float64)
					english, _ := nameMeta["english"].(string)
					arabic, _ := nameMeta["arabic"].(string)
					meaning, _ := nameMeta["meaning"].(string)
					summary, _ := nameMeta["summary"].(string)

					nameTitle := fmt.Sprintf("%s - %s - %s", english, arabic, meaning)
					nameLink := fmt.Sprintf("https://reminder.dev/names/%d", int(number))

					fmt.Fprintf(w, `    <item>
      <title>%s</title>
      <link>%s</link>
      <guid>%s</guid>
      <pubDate>%s</pubDate>
      <description><![CDATA[%s]]></description>
    </item>
`, nameTitle, nameLink, nameLink, pubDate, summary)
				}
			}

			// Then, add daily summary at the end (for single daily consumption)
			entry, hasDaily := dailyIndex[date]
			if hasDaily {
				entryMap, ok := entry.(map[string]interface{})
				if ok {
					verse := ""
					hadith := ""
					name := ""
					hijri := ""

					if v, ok := entryMap["verse"].(string); ok {
						verse = v
					}
					if h, ok := entryMap["hadith"].(string); ok {
						hadith = h
					}
					if n, ok := entryMap["name"].(string); ok {
						name = n
					}
					if hj, ok := entryMap["hijri"].(string); ok {
						hijri = hj
					}

					title := fmt.Sprintf("Daily Reminder - %s", date)
					if hijri != "" {
						title = fmt.Sprintf("Daily Reminder - %s (%s)", date, hijri)
					}

					// Combine all three into one item description
					description := ""
					if verse != "" {
						description += "<h3>Verse</h3>\n" + verse + "\n\n"
					}
					if hadith != "" {
						description += "<h3>Hadith</h3>\n" + hadith + "\n\n"
					}
					if name != "" {
						description += "<h3>Name</h3>\n" + name
					}

					if description != "" {
						fmt.Fprintf(w, `    <item>
      <title>%s</title>
      <link>https://reminder.dev/daily/%s</link>
      <guid>https://reminder.dev/daily/%s</guid>
      <pubDate>%s</pubDate>
      <description><![CDATA[%s]]></description>
    </item>
`, title, date, date, basePubDate, description)
					}
				}
			}
		}

		fmt.Fprintf(w, `  </channel>
</rss>`)
	})

	http.HandleFunc("/api/names", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(njson))
	})

	http.HandleFunc("/api/names/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		if len(id) == 0 {
			w.WriteHeader(http.StatusNotFound)
			w.Write([]byte("{}"))
			return
		}

		name, _ := strconv.Atoi(id)
		if name < 1 || name > len(*n) {
			w.WriteHeader(http.StatusNotFound)
			w.Write([]byte("{}"))
			return
		}

		b := n.Get(name)
		json, _ := json.Marshal(b)
		w.Write(json)
	})

	http.HandleFunc("/api/hadith/books", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		b, _ := json.Marshal(b.Index().Books)
		w.Write(b)
	})

	http.HandleFunc("/api/hadith", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte(hjson))
	})

	http.HandleFunc("/api/hadith/{book}", func(w http.ResponseWriter, r *http.Request) {
		bk := r.PathValue("book")
		if len(bk) == 0 {
			return
		}

		book, _ := strconv.Atoi(bk)
		if book < 1 || book > len(b.Books) {
			return
		}

		b := b.Get(book).JSON()

		w.Write(b)
	})

	http.HandleFunc("/api/explain", func(w http.ResponseWriter, r *http.Request) {
		b, _ := io.ReadAll(r.Body)
		var data map[string]interface{}
		json.Unmarshal(b, &data)

		q := data["q"].(string)

		prompt := `Generate a detailed summary for the following with it's meaning and origin, output the response as JSON with the fields: 
		text, context, summary. Each field itself should be a string. Text is the text that was provided. Context is contextual information 
		for the origin of the text or background information required. Summary is a more detailed summary in relation to the text and context.

		%s
		`

		answer := askLLM(r.Context(), nil, fmt.Sprintf(prompt, q))
		w.Write([]byte(answer))
	})

	http.HandleFunc("/api/translate", func(w http.ResponseWriter, r *http.Request) {
		b, _ := io.ReadAll(r.Body)
		var data map[string]interface{}
		json.Unmarshal(b, &data)

		q := data["q"].(string)

		prompt := `Translate the following into a modern interpretation, transliterate and then word by word. 
		For each word provide 3 alternatives and a transliteration in english. Generate the output as JSON. 
		The response will be served via an API so ensure it's entirely json compliant with no markdown.
		Ensure consistency in the output using fields translation, transliteration and word_by_word.
		The word_by_word field itself should be an array with word in english, arabic, translations and 
		transliteration.:

		%s`

		answer := askLLM(r.Context(), nil, fmt.Sprintf(prompt, q))
		w.Write([]byte(answer))
	})

	http.HandleFunc("/api/search", func(w http.ResponseWriter, r *http.Request) {
		select {
		case <-indexed:
		default:
			// not indexed yet because blocked
			w.Write([]byte(`{"error": "Indexing content"}`))
			return
		}

		// indexed or no index of any kind

		if r.Method == "GET" {
			var ctx string

			// look for the context cookie
			c, err := r.Cookie("session")
			if err == nil {
				ctx = c.Value
			}

			if len(ctx) == 0 {
				w.Write([]byte(`{}`))
				return
			}

			// pull the context which we only store in memory for now
			h, ok := history[ctx]
			if !ok {
				h = []string{}
			}

			out, _ := json.Marshal(map[string]interface{}{
				"session": ctx,
				"history": h,
			})

			w.Write(out)
			return
		}

		if r.Method == "POST" {
			b, _ := io.ReadAll(r.Body)
			var data map[string]interface{}
			json.Unmarshal(b, &data)

			q, _ := data["q"].(string)

			// summarise defaults to true when absent for backward compat.
			// The new web UI explicitly sets summarise=false for the fast
			// path that only returns references, then issues a second call
			// with summarise=true to fetch the LLM answer.
			summarise := true
			if v, ok := data["summarise"]; ok {
				if bv, ok := v.(bool); ok {
					summarise = bv
				}
			}

			res, err := idx.Query(q)
			if err != nil {
				http.Error(w, err.Error(), 500)
				return
			}

			for _, r := range res {
				for k, v := range r.Metadata {
					delete(r.Metadata, k)
					r.Metadata[strings.ToLower(k)] = v
				}
			}

			if !summarise {
				output, _ := json.Marshal(map[string]interface{}{
					"q":          q,
					"answer":     "",
					"references": res,
				})
				w.Write(output)
				return
			}

			var tokens int
			var contexts []string

			for _, r := range res {
				if tokens >= 8000 {
					break
				}

				b, _ := json.Marshal(r)
				tokens += len(b)
				// TODO: maybe just provide text
				contexts = append(contexts, string(b))
			}

			answer := askLLM(r.Context(), contexts, q)
			answerMD := string(app.Render([]byte(answer)))

			output, _ := json.Marshal(map[string]interface{}{
				"q":          q,
				"answer":     answerMD,
				"references": res,
			})
			w.Write(output)

			var ctx string

			// look for the context cookie
			c, err := r.Cookie("session")
			if err == nil {
				ctx = c.Value
				h, ok := history[ctx]
				if !ok {
					h = []string{}
				}
				h = append([]string{q, answerMD}, h...)
				history[ctx] = h
			}

			return
		}
	})

	fmt.Println("Registering routes")
	httpMux := http.DefaultServeMux
	api.RegisterRoutes(httpMux)

	// Register MCP server
	mcpServer := api.NewServer("reminder", "1.0.0")

	mcpServer.AddTool("get_latest", "Get the latest reminder (updated hourly) with a verse, hadith and name of Allah", api.InputSchema{
		Type: "object",
	}, func(args map[string]interface{}) (string, error) {
		mtx.RLock()
		resp := map[string]interface{}{
			"name":    dailyName,
			"hadith":  dailyHadith,
			"verse":   dailyVerse,
			"links":   links,
			"updated": dailyUpdated.Format(time.RFC3339),
			"message": dailyMessage,
		}
		mtx.RUnlock()
		b, _ := json.Marshal(resp)
		return string(b), nil
	})

	mcpServer.AddTool("get_daily", "Get today's daily reminder with a verse, hadith and name of Allah", api.InputSchema{
		Type: "object",
	}, func(args map[string]interface{}) (string, error) {
		today := time.Now().UTC().Format("2006-01-02")
		mtx.RLock()
		defer mtx.RUnlock()
		if entry, ok := dailyIndex[today]; ok {
			b, _ := json.Marshal(entry)
			return string(b), nil
		}
		message := "In the Name of Allah—the Most Beneficent, Most Merciful"
		resp := map[string]interface{}{
			"name":    dailyName,
			"hadith":  dailyHadith,
			"verse":   dailyVerse,
			"links":   links,
			"updated": dailyUpdated.Format(time.RFC3339),
			"message": message,
			"hijri":   daily.Date().Display,
			"date":    today,
		}
		b, _ := json.Marshal(resp)
		return string(b), nil
	})

	mcpServer.AddTool("get_daily_by_date", "Get a daily reminder for a specific date", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"date": {Type: "string", Description: "Date in YYYY-MM-DD format"},
		},
		Required: []string{"date"},
	}, func(args map[string]interface{}) (string, error) {
		date, _ := args["date"].(string)
		if date == "" {
			return "", fmt.Errorf("date is required")
		}
		mtx.RLock()
		defer mtx.RUnlock()
		if entry, ok := dailyIndex[date]; ok {
			b, _ := json.Marshal(entry)
			return string(b), nil
		}
		return "", fmt.Errorf("not found")
	})

	mcpServer.AddTool("get_quran_chapters", "Get a list of all Quran chapters", api.InputSchema{
		Type: "object",
	}, func(args map[string]interface{}) (string, error) {
		b, _ := json.Marshal(q.Index().Chapters)
		return string(b), nil
	})

	mcpServer.AddTool("get_quran_chapter", "Get a chapter of the Quran with all its verses", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"chapter": {Type: "number", Description: "Chapter number (1-114)"},
		},
		Required: []string{"chapter"},
	}, func(args map[string]interface{}) (string, error) {
		chNum, ok := args["chapter"].(float64)
		if !ok {
			return "", fmt.Errorf("chapter is required")
		}
		chapter := int(chNum)
		if chapter < 1 || chapter > 114 {
			return "", fmt.Errorf("chapter must be between 1 and 114")
		}
		return string(q.Get(chapter).JSON()), nil
	})

	mcpServer.AddTool("get_quran_verse", "Get a specific verse of the Quran with word-by-word translation", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"chapter": {Type: "number", Description: "Chapter number (1-114)"},
			"verse":   {Type: "number", Description: "Verse number"},
		},
		Required: []string{"chapter", "verse"},
	}, func(args map[string]interface{}) (string, error) {
		chNum, ok := args["chapter"].(float64)
		if !ok {
			return "", fmt.Errorf("chapter is required")
		}
		veNum, ok := args["verse"].(float64)
		if !ok {
			return "", fmt.Errorf("verse is required")
		}
		chapter := int(chNum)
		verse := int(veNum)
		if chapter < 1 || chapter > 114 {
			return "", fmt.Errorf("chapter must be between 1 and 114")
		}
		cc := q.Get(chapter)
		if verse < 1 || verse > len(cc.Verses) {
			return "", fmt.Errorf("verse out of range")
		}
		return string(cc.Verses[verse-1].JSON()), nil
	})

	mcpServer.AddTool("get_hadith_books", "Get a list of all hadith books in Sahih Bukhari", api.InputSchema{
		Type: "object",
	}, func(args map[string]interface{}) (string, error) {
		bks, _ := json.Marshal(b.Index().Books)
		return string(bks), nil
	})

	mcpServer.AddTool("get_hadith_book", "Get a specific book from Sahih Bukhari with all its hadiths", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"book": {Type: "number", Description: "Book number"},
		},
		Required: []string{"book"},
	}, func(args map[string]interface{}) (string, error) {
		bkNum, ok := args["book"].(float64)
		if !ok {
			return "", fmt.Errorf("book is required")
		}
		book := int(bkNum)
		if book < 1 || book > len(b.Books) {
			return "", fmt.Errorf("book out of range")
		}
		return string(b.Get(book).JSON()), nil
	})

	mcpServer.AddTool("get_names", "Get all 99 Names of Allah", api.InputSchema{
		Type: "object",
	}, func(args map[string]interface{}) (string, error) {
		return string(njson), nil
	})

	mcpServer.AddTool("get_name", "Get a specific Name of Allah with description and Quran references", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"id": {Type: "number", Description: "Name number (1-99)"},
		},
		Required: []string{"id"},
	}, func(args map[string]interface{}) (string, error) {
		idNum, ok := args["id"].(float64)
		if !ok {
			return "", fmt.Errorf("id is required")
		}
		id := int(idNum)
		if id < 1 || id > len(*n) {
			return "", fmt.Errorf("id must be between 1 and 99")
		}
		byt, _ := json.Marshal(n.Get(id))
		return string(byt), nil
	})

	mcpServer.AddTool("search", "Search Islamic content and get AI-summarised answers from the Quran, Hadith and Names of Allah", api.InputSchema{
		Type: "object",
		Properties: map[string]api.Property{
			"q": {Type: "string", Description: "The question to ask"},
		},
		Required: []string{"q"},
	}, func(args map[string]interface{}) (string, error) {
		select {
		case <-indexed:
		default:
			return "", fmt.Errorf("indexing content, please try again later")
		}

		question, ok := args["q"].(string)
		if !ok || question == "" {
			return "", fmt.Errorf("q is required")
		}

		res, err := idx.Query(question)
		if err != nil {
			return "", err
		}

		var tokens int
		var contexts []string
		for _, r := range res {
			if tokens >= 8000 {
				break
			}
			for k, v := range r.Metadata {
				delete(r.Metadata, k)
				r.Metadata[strings.ToLower(k)] = v
			}
			b, _ := json.Marshal(r)
			tokens += len(b)
			contexts = append(contexts, string(b))
		}

		answer := askLLM(context.Background(), contexts, question)

		output, _ := json.Marshal(map[string]interface{}{
			"q":          question,
			"answer":     answer,
			"references": res,
		})
		return string(output), nil
	})

	http.Handle("/mcp", mcpServer)

	getVerse := func(ch *quran.Chapter, ve *quran.Verse) (string, int, int, string) {
		verseText := ve.Text
		verseStart := ve.Number
		verseEnd := ve.Number

		for i := 0; i < 10; i++ {
			// done
			if x := verseText[len(verseText)-1]; x == '.' || x == '!' || x == '"' {
				break
			}

			idx := ve.Number + 1

			if ch.Number == 1 || ch.Number == 9 {
				idx = ve.Number
			}

			// bail out - check bounds
			if idx < 0 || idx >= len(ch.Verses) {
				break
			}

			// increment
			ve = ch.Verses[idx]

			if v := verseText[len(verseText)-1]; v == ',' || string(v) == "—" || unicode.IsLetter(rune(v)) || v == ';' {
				verseText += " " + ve.Text
			} else {
				verseText += "\n\n" + ve.Text
			}
			verseEnd = ve.Number
		}

		verseNumber := fmt.Sprintf("%d", verseStart)

		if verseStart != verseEnd {
			verseNumber += fmt.Sprintf("-%d", verseEnd)
		}

		formatted := fmt.Sprintf("%s - %s - %d:%s\n\n%s", ch.Name, ch.English, ch.Number, verseNumber, verseText)
		return formatted, verseStart, verseEnd, verseText
	}

	daily := func() {
		// Check if we're within the first 5 minutes after midnight UTC
		// This handles server restarts that happen right at midnight
		isWithinGracePeriod := func() bool {
			now := time.Now().UTC()
			midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.UTC)
			sinceMidnight := now.Sub(midnight)
			return sinceMidnight >= 0 && sinceMidnight < 5*time.Minute
		}

		for {
			fmt.Println("Running daily")

			mtx.Lock()

			nam := (*n)[rnd.Int()%len((*n))]
			bookIdx := rnd.Int() % len(b.Books)
			book := b.Books[bookIdx]

			// Safety check for books with no hadiths
			if len(book.Hadiths) == 0 {
				fmt.Printf("Book %d (%s) has no hadiths, skipping\n", bookIdx, book.Name)
				mtx.Unlock()
				continue
			}

			chap := q.Chapters[rnd.Int()%len(q.Chapters)]

			// Safety check for chapters with no verses
			if len(chap.Verses) == 0 {
				fmt.Printf("Chapter %d has no verses, skipping\n", chap.Number)
				mtx.Unlock()
				continue
			}

			ver := chap.Verses[rnd.Int()%len(chap.Verses)]
			hadithIdx := rnd.Int() % len(book.Hadiths)
			had := book.Hadiths[hadithIdx]

			fmt.Printf("Selected: Book %d (%s), Hadith %d, Chapter %d, Verse %d\n", bookIdx, book.Name, hadithIdx, chap.Number, ver.Number)

			// make sure we're starting from the begining of a verse
			if !isCapital(ver.Text) {
				mtx.Unlock()
				continue
			}

			// skip zero verse e.g bismillah
			if ver.Number == 0 {
				mtx.Unlock()
				continue
			}

			dailyName = fmt.Sprintf("%s - %s - %s\n\n%s", nam.English, nam.Arabic, nam.Meaning, nam.Summary)
			verseFormatted, verseStart, verseEnd, verseText := getVerse(chap, ver)
			dailyVerse = verseFormatted
			// Use new hadith format fields with fallback to legacy
			hadithNarrator := had.Narrator
			if hadithNarrator == "" {
				hadithNarrator = had.By
			}
			hadithText := had.English
			if hadithText == "" {
				hadithText = had.Text
			}
			hadithNum := had.Number
			if hadithNum == 0 {
				hadithNum = 1
			}
			dailyHadith = fmt.Sprintf("%s - %s\n\n%s", book.Name, hadithNarrator, hadithText)

			// Generate the contextual message once and cache it with the daily data
			dailyMessage = generateMessage(context.Background(), dailyVerse, dailyHadith, dailyName)

			links = map[string]string{
				"verse":  fmt.Sprintf("/quran/%d#%d", chap.Number, verseStart),
				"hadith": fmt.Sprintf("/hadith/%d#%d", book.Number, hadithNum),
				"name":   fmt.Sprintf("/names/%d", nam.Number),
			}

			dailyUpdated = time.Now()
			hijriDate := daily.Date().Display
			today := time.Now().UTC().Format("2006-01-02")
			timestamp := time.Now().UTC().Format(time.RFC3339)

			// Save hourly reminder with metadata
			hourlyData := map[string]interface{}{
				"timestamp": timestamp,
				"verse_meta": map[string]interface{}{
					"chapter":      chap.Number,
					"chapter_name": chap.English,
					"verse_start":  verseStart,
					"verse_end":    verseEnd,
					"text":         verseText,
				},
				"hadith_meta": map[string]interface{}{
					"book":      book.Number,
					"book_name": book.Name,
					"narrator":  hadithNarrator,
					"number":    hadithNum,
					"text":      hadithText,
				},
				"name_meta": map[string]interface{}{
					"number":  nam.Number,
					"english": nam.English,
					"arabic":  nam.Arabic,
					"meaning": nam.Meaning,
					"summary": nam.Summary,
				},
			}
			saveHourlyReminder(today, timestamp, hourlyData)

			mtx.Unlock()

			// Check if we should send push notification (new day or within grace period after midnight)
			if lastPushDate != today || (lastPushDate == today && isWithinGracePeriod()) {
				mtx.Lock()

				// Compose a user-friendly notification message
				notifyVerse := dailyVerse

				if len(dailyVerse) > 250 {
					notifyVerse = notifyVerse[:250] + "..."
				}

				dailyData := map[string]interface{}{
					"verse":   dailyVerse,
					"hadith":  dailyHadith,
					"name":    dailyName,
					"hijri":   hijriDate,
					"date":    today,
					"links":   links,
					"updated": dailyUpdated.Format(time.RFC3339),
					"message": dailyMessage,
				}

				// Save to daily.json
				saveDaily(today, dailyData)

				payload := map[string]interface{}{
					"title": "Reminder",
					"body":  notifyVerse,
					"data": map[string]interface{}{
						"url": "/daily/" + today,
					},
				}

				b, _ := json.Marshal(payload)

				// Only send if we haven't already sent today
				if lastPushDate != today {
					fmt.Println("Sending push notification at midnight UTC")

					errors := api.SendPushToAll(string(b))
					if len(errors) > 0 {
						fmt.Println("Push notification errors:")
						for _, err := range errors {
							fmt.Println(err)
						}
					}

					lastPushDate = today
					saveLastPushDate(today)
				} else {
					fmt.Println("Push notification already sent today, skipping")
				}

				mtx.Unlock()
			}

			// Update hourly for /api/latest
			time.Sleep(time.Hour)
		}
	}

	if *ServerFlag {
		fmt.Println("Starting daily")
		go daily()

		fmt.Println("Starting server :8080")
		if err := http.ListenAndServe(":8080", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if *EnvFlag == "dev" {
				w.Header().Set("Access-Control-Allow-Origin", "http://localhost:5173")
				w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
				w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
				w.Header().Set("Access-Control-Allow-Credentials", "true")

				if r.Method == "OPTIONS" {
					w.WriteHeader(http.StatusOK)
					return
				}
			}

			// check cookies
			if c, err := r.Cookie("session"); err != nil || c == nil || len(c.Value) == 0 {
				var secure bool

				if h := r.Header.Get("X-Forwarded-Proto"); h == "https" {
					secure = true
				}

				http.SetCookie(w, &http.Cookie{
					Name:   "session",
					Value:  uuid.New().String(),
					Secure: secure,
				})
			}

			http.DefaultServeMux.ServeHTTP(w, r)
		})); err != nil {
			fmt.Printf("Server error: %v\n", err)
		}
	}

	// wait for index
	<-indexed
}