feat: Hijri calendar, virtual midnight crossover, overlap rejection, WAL mode

- Hijri (قمری) calendar added as 3rd calendar option with tabular conversion - Calendar type select menu (like accent) with gregorian/jalali/hijri - Calendar type applied to exports and reports - Midnight crossover: virtual splits at computation time (no synthetic DB events) - Handles both UTC and local timezone boundaries - Timezone changes handled naturally (recomputed on-the-fly) - Rate limiting per user ID instead of chat ID - WAL mode enabled for SQLite - Smart reply keyboard updates after every state change - Overlapping time edits rejected (must preserve in/out alternation) - Single event deletion warns if timeline needs repair - Day off no longer prevents clock in/out - Accent colors shown with descriptive names in select menu - Delete button label changed to DEL for visual distinction
2026-06-24 09:39:15 +03:30
parent 6f6cc6f184
commit 9d123316e6
6 changed files with 1030 additions and 59 deletions
--- a/internal/bot/handlers.go
+++ b/internal/bot/handlers.go
@@ -35,14 +35,14 @@ func NewHandler(bot *tgbotapi.BotAPI, store *db.Store, allowed map[int64]bool) *

 type actionFunc func(int64) (string, error)

-func (h *Handler) isRateLimited(chatID int64) bool {
+func (h *Handler) isRateLimited(userID int64) bool {
 	h.mu.Lock()
 	defer h.mu.Unlock()
 	now := time.Now()
-	if last, ok := h.lastMsgTime[chatID]; ok && now.Sub(last) < rateLimitInterval {
+	if last, ok := h.lastMsgTime[userID]; ok && now.Sub(last) < rateLimitInterval {
 		return true
 	}
-	h.lastMsgTime[chatID] = now
+	h.lastMsgTime[userID] = now
 	return false
 }

@@ -52,6 +52,7 @@ func (h *Handler) handleActionMsg(msg *tgbotapi.Message, fn actionFunc) {
 		h.sendText(msg.Chat.ID, err.Error())
 	} else {
 		h.sendSuccessWithMenu(msg.Chat.ID, text)
+		h.updateReplyKeyboard(msg.Chat.ID)
 	}
 }

@@ -65,6 +66,7 @@ func (h *Handler) handleActionCallback(chatID int64, msgID int, callbackID strin
 	kb := backKeyboard()
 	edit.ReplyMarkup = &kb
 	h.Bot.Send(edit)
+	h.updateReplyKeyboard(chatID)
 }

 func (h *Handler) HandleMessage(update tgbotapi.Update) {
@@ -72,7 +74,11 @@ func (h *Handler) HandleMessage(update tgbotapi.Update) {
 	if len(h.AllowedUsers) > 0 && !h.AllowedUsers[msg.Chat.ID] {
 		return
 	}
-	if h.isRateLimited(msg.Chat.ID) {
+	user, err := h.getOrCreateUser(msg.Chat.ID)
+	if err != nil {
+		return
+	}
+	if h.isRateLimited(user.ID) {
 		return
 	}
 	slog.Info("message", "chat_id", msg.Chat.ID, "text", msg.Text)
@@ -91,6 +97,10 @@ func (h *Handler) HandleMessage(update tgbotapi.Update) {
 		h.handleExport(msg)
 	case "/dayoff":
 		h.handleActionMsg(msg, h.dayOff)
+	case "/history":
+		h.handleHistoryMsg(msg)
+	case "/edit":
+		h.handleEditMsg(msg)
 	case "/reporttoggle":
 		h.handleActionMsg(msg, h.toggleReport)
 	case "/setreporttime":
@@ -108,7 +118,12 @@ func (h *Handler) HandleCallback(update tgbotapi.Update) {
 		h.Bot.Request(tgbotapi.NewCallback(cb.ID, "Unauthorized"))
 		return
 	}
-	if h.isRateLimited(cb.Message.Chat.ID) {
+	user, err := h.getOrCreateUser(cb.Message.Chat.ID)
+	if err != nil {
+		h.Bot.Request(tgbotapi.NewCallback(cb.ID, ""))
+		return
+	}
+	if h.isRateLimited(user.ID) {
 		h.Bot.Request(tgbotapi.NewCallback(cb.ID, ""))
 		return
 	}
@@ -127,12 +142,18 @@ func (h *Handler) HandleCallback(update tgbotapi.Update) {
 		h.handleActionCallback(chatID, msgID, cb.ID, h.report)
 	case "export":
 		h.exportCallback(chatID, msgID, cb.ID)
+	case "noop":
+		h.Bot.Request(tgbotapi.NewCallback(cb.ID, ""))
 	case "dayoff":
 		h.handleActionCallback(chatID, msgID, cb.ID, h.dayOff)
 	case "settings":
 		h.settingsCallback(chatID, msgID, cb.ID)
+	case "caltype":
+		h.calTypeCallback(chatID, msgID, cb.ID)
 	case "accent":
 		h.accentCallback(chatID, msgID, cb.ID)
+	case "history":
+		h.historyCallback(chatID, msgID, cb.ID)
 	case "reporttoggle":
 		h.handleActionCallback(chatID, msgID, cb.ID, h.toggleReport)
 	case "reporttime":
@@ -150,6 +171,11 @@ func (h *Handler) HandleCallback(update tgbotapi.Update) {
 			h.selectAccent(chatID, msgID, cb.ID, cb.Data[7:])
 			return
 		}
+		if len(cb.Data) > 4 && cb.Data[:4] == "cal_" {
+			h.selectCalendar(chatID, msgID, cb.ID, cb.Data[4:])
+			return
+		}
+		h.handleHistoryCallback(chatID, msgID, cb.ID, cb.Data)
 	}
 }

@@ -179,9 +205,6 @@ func (h *Handler) clockIn(chatID int64) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	if day.IsDayOff {
-		return "", errors.New("Today is a day off. Use /dayoff to remove it first.")
-	}

 	last, err := h.DB.GetLastEvent(user.ID)
 	if err != nil && err != sql.ErrNoRows {
@@ -190,23 +213,11 @@ func (h *Handler) clockIn(chatID int64) (string, error) {

 	if last != nil && last.EventType == "in" {
 		loc, _ := time.LoadLocation(user.Timezone)
-		lastTime := time.Unix(last.OccurredAt, 0).In(loc)
 		now := time.Now().In(loc)
-		lastDay := lastTime.Format("2006-01-02")
-		today := now.Format("2006-01-02")
-
-		if lastDay == today {
+		lastTime := time.Unix(last.OccurredAt, 0).In(loc)
+		if lastTime.Format("2006-01-02") == now.Format("2006-01-02") {
 			return "", errors.New("Already clocked in")
 		}
-
-		midnight := time.Date(lastTime.Year(), lastTime.Month(), lastTime.Day(), 23, 59, 59, 0, loc)
-		prevDay, err := h.DB.GetOrCreateDay(user.ID, lastDay)
-		if err != nil {
-			return "", err
-		}
-		if err := h.DB.CreateEvent(user.ID, prevDay.ID, "out", nil, midnight.Unix(), "auto midnight"); err != nil {
-			return "", err
-		}
 	}

 	loc, _ := time.LoadLocation(user.Timezone)
@@ -223,9 +234,6 @@ func (h *Handler) clockOut(chatID int64) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	if day.IsDayOff {
-		return "", errors.New("Today is a day off. Use /dayoff to remove it first.")
-	}
 	last, err := h.DB.GetLastEvent(user.ID)
 	if err != nil {
 		return "", err
@@ -350,6 +358,15 @@ func (h *Handler) handleStart(msg *tgbotapi.Message) {
 	h.Bot.Send(menu)
 }

+func (h *Handler) updateReplyKeyboard(chatID int64) {
+	msg := tgbotapi.NewMessage(chatID, "\u200C")
+	msg.ReplyMarkup = h.smartKeyboard(chatID)
+	sent, err := h.Bot.Send(msg)
+	if err == nil {
+		h.Bot.Request(tgbotapi.NewDeleteMessage(chatID, sent.MessageID))
+	}
+}
+
 func (h *Handler) handleWorkTypeMsg(msg *tgbotapi.Message) {
 	user, day, err := h.getUserToday(msg.Chat.ID)
 	if err != nil {
@@ -418,6 +435,7 @@ func (h *Handler) selectWorkType(chatID int64, msgID int, callbackID, idStr stri
 	if err := h.DB.UpdateDay(day); err != nil {
 		return
 	}
+	h.updateReplyKeyboard(chatID)
 	text := fmt.Sprintf("Work type set to: %s", wt.Name)
 	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
 	kb := backKeyboard()
@@ -446,12 +464,18 @@ func (h *Handler) buildSettingsKeyboard(user *db.User) (string, tgbotapi.InlineK
 	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
 		tgbotapi.NewInlineKeyboardButtonData(fmt.Sprintf("Accent: %s", user.ExportAccent), "accent"),
 	))
+	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData(fmt.Sprintf("Calendar: %s", user.Calendar), "caltype"),
+	))
 	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
 		tgbotapi.NewInlineKeyboardButtonData(fmt.Sprintf("Report: %s", reportStatus), "reporttoggle"),
 	))
 	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
 		tgbotapi.NewInlineKeyboardButtonData(fmt.Sprintf("Report time: %s", user.ReportTime), "reporttime"),
 	))
+	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("History", "history"),
+	))
 	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
 		tgbotapi.NewInlineKeyboardButtonData("Back to Menu", "back_menu"),
 	))
@@ -471,15 +495,23 @@ func (h *Handler) accentCallback(chatID int64, msgID int, callbackID string) {
 }

 func (h *Handler) buildAccentKeyboard(user *db.User) (string, tgbotapi.InlineKeyboardMarkup) {
-	accents := []string{"ocean", "beach", "rose", "catppuccin"}
+	accents := []struct {
+		name  string
+		color string
+	}{
+		{"ocean", "Blue"},
+		{"beach", "Warm"},
+		{"rose", "Pink"},
+		{"catppuccin", "Purple"},
+	}
 	var rows [][]tgbotapi.InlineKeyboardButton
 	for _, a := range accents {
-		label := a
-		if a == user.ExportAccent {
-			label = "> " + a
+		label := fmt.Sprintf("%s (%s)", a.name, a.color)
+		if a.name == user.ExportAccent {
+			label = "> " + label
 		}
 		rows = append(rows, tgbotapi.NewInlineKeyboardRow(
-			tgbotapi.NewInlineKeyboardButtonData(label, "accent_"+a),
+			tgbotapi.NewInlineKeyboardButtonData(label, "accent_"+a.name),
 		))
 	}
 	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
@@ -502,6 +534,7 @@ func (h *Handler) selectAccent(chatID int64, msgID int, callbackID, name string)
 	if err := h.DB.UpdateUser(user); err != nil {
 		return
 	}
+	h.updateReplyKeyboard(chatID)
 	text := fmt.Sprintf("Accent set to: %s", name)
 	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
 	kb := tgbotapi.NewInlineKeyboardMarkup(
@@ -542,6 +575,604 @@ func (h *Handler) backToSettings(chatID int64, msgID int, callbackID string) {
 	h.Bot.Send(edit)
 }

+func (h *Handler) calTypeCallback(chatID int64, msgID int, callbackID string) {
+	defer h.Bot.Request(tgbotapi.NewCallback(callbackID, ""))
+	user, err := h.getOrCreateUser(chatID)
+	if err != nil {
+		return
+	}
+	text, kb := h.buildCalendarKeyboard(user)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kb
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) buildCalendarKeyboard(user *db.User) (string, tgbotapi.InlineKeyboardMarkup) {
+	cals := []string{"gregorian", "jalali", "hijri"}
+	calLabels := map[string]string{
+		"gregorian": "Gregorian",
+		"jalali":    "Jalali",
+		"hijri":     "Hijri",
+	}
+	var rows [][]tgbotapi.InlineKeyboardButton
+	for _, c := range cals {
+		label := calLabels[c]
+		if c == user.Calendar {
+			label = "> " + label
+		}
+		rows = append(rows, tgbotapi.NewInlineKeyboardRow(
+			tgbotapi.NewInlineKeyboardButtonData(label, "cal_"+c),
+		))
+	}
+	rows = append(rows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back to Settings", "back_settings"),
+	))
+	return "Select calendar type:", tgbotapi.NewInlineKeyboardMarkup(rows...)
+}
+
+func (h *Handler) selectCalendar(chatID int64, msgID int, callbackID, name string) {
+	defer h.Bot.Request(tgbotapi.NewCallback(callbackID, ""))
+	valid := map[string]bool{"gregorian": true, "jalali": true, "hijri": true}
+	if !valid[name] {
+		return
+	}
+	user, err := h.getOrCreateUser(chatID)
+	if err != nil {
+		return
+	}
+	user.Calendar = name
+	if err := h.DB.UpdateUser(user); err != nil {
+		return
+	}
+	h.updateReplyKeyboard(chatID)
+	text, kb := h.buildSettingsKeyboard(user)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kb
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) handleHistoryMsg(msg *tgbotapi.Message) {
+	h.sendCalendar(msg.Chat.ID, 0, 0, 0)
+}
+
+func (h *Handler) historyCallback(chatID int64, msgID int, callbackID string) {
+	defer h.Bot.Request(tgbotapi.NewCallback(callbackID, ""))
+	h.editCalendar(chatID, msgID, 0, 0)
+}
+
+func (h *Handler) handleEditMsg(msg *tgbotapi.Message) {
+	date := msg.CommandArguments()
+	if date == "" {
+		h.sendText(msg.Chat.ID, "Usage: /edit YYYY-MM-DD")
+		return
+	}
+	if len(date) != 10 || date[4] != '-' || date[7] != '-' {
+		h.sendText(msg.Chat.ID, "Invalid date. Use: /edit YYYY-MM-DD")
+		return
+	}
+	user, err := h.getOrCreateUser(msg.Chat.ID)
+	if err != nil {
+		h.sendText(msg.Chat.ID, "Error loading profile")
+		return
+	}
+	loc, _ := time.LoadLocation(user.Timezone)
+	h.sendDayView(msg.Chat.ID, 0, user, date, loc, true)
+}
+
+func (h *Handler) handleHistoryCallback(chatID int64, msgID int, callbackID, data string) {
+	defer h.Bot.Request(tgbotapi.NewCallback(callbackID, ""))
+	user, err := h.getOrCreateUser(chatID)
+	if err != nil {
+		return
+	}
+	loc, _ := time.LoadLocation(user.Timezone)
+
+	if data == "history" {
+		h.editCalendar(chatID, msgID, 0, 0)
+		return
+	}
+
+	var y, m int
+	var date string
+	var eid int64
+
+	// cal_prev_YYYY_M
+	if n, _ := fmt.Sscanf(data, "cal_prev_%d_%d", &y, &m); n == 2 {
+		m--
+		if m < 1 {
+			m = 12
+			y--
+		}
+		h.editCalendar(chatID, msgID, y, m)
+		return
+	}
+	// cal_next_YYYY_M
+	if n, _ := fmt.Sscanf(data, "cal_next_%d_%d", &y, &m); n == 2 {
+		m++
+		if m > 12 {
+			m = 1
+			y++
+		}
+		h.editCalendar(chatID, msgID, y, m)
+		return
+	}
+	// cal_day_DATE
+	if n, _ := fmt.Sscanf(data, "cal_day_%s", &date); n == 1 && len(date) == 10 {
+		h.editDayView(chatID, msgID, user, date, loc)
+		return
+	}
+	// back_day_EVENTID -> go back to day view
+	if n, _ := fmt.Sscanf(data, "back_day_%d", &eid); n == 1 {
+		h.backToDayView(chatID, msgID, user, eid, loc)
+		return
+	}
+	// settype_EVENTID_WTID
+	var wtid int64
+	if n, _ := fmt.Sscanf(data, "settype_%d_%d", &eid, &wtid); n == 2 {
+		h.setEventWorkType(chatID, msgID, user, eid, wtid, loc)
+		return
+	}
+	// edit_type_EVENTID -> show work type picker
+	if n, _ := fmt.Sscanf(data, "edit_type_%d", &eid); n == 1 {
+		h.editEventType(chatID, msgID, user, eid, loc)
+		return
+	}
+	// delete_EVENTID
+	if n, _ := fmt.Sscanf(data, "delete_%d", &eid); n == 1 {
+		h.deleteEventPrompt(chatID, msgID, user, eid, loc)
+		return
+	}
+	// delconf_EVENTID
+	if n, _ := fmt.Sscanf(data, "delconf_%d", &eid); n == 1 {
+		h.deleteEventConfirm(chatID, msgID, user, eid, loc)
+		return
+	}
+	// edit_time_EVENTID -> show hour picker
+	if n, _ := fmt.Sscanf(data, "edit_time_%d", &eid); n == 1 {
+		h.editEventTime(chatID, msgID, user, eid, loc)
+		return
+	}
+	// edittm_EVENTID_HH_MM -> set time
+	var hh, mm int
+	if n, _ := fmt.Sscanf(data, "edittm_%d_%d_%d", &eid, &hh, &mm); n == 3 {
+		h.editEventTimeSet(chatID, msgID, user, eid, hh, mm, loc)
+		return
+	}
+	// edittm_EVENTID_HH -> show minute picker
+	if n, _ := fmt.Sscanf(data, "edittm_%d_%d", &eid, &hh); n == 2 {
+		h.editEventTimeMin(chatID, msgID, user, eid, hh, loc)
+		return
+	}
+}
+
+func (h *Handler) sendCalendar(chatID int64, msgID int, year, month int) {
+	h.editCalendar(chatID, msgID, year, month)
+}
+
+func (h *Handler) editCalendar(chatID int64, msgID int, year, month int) {
+	user, err := h.getOrCreateUser(chatID)
+	if err != nil {
+		return
+	}
+	loc, _ := time.LoadLocation(user.Timezone)
+	now := time.Now().In(loc)
+
+	if year == 0 || month == 0 {
+		switch user.Calendar {
+		case "jalali":
+			jy, jm, _ := gregorianToJalali(now.Year(), int(now.Month()), now.Day())
+			year, month = jy, jm
+		case "hijri":
+			hy, hm, _ := gregorianToHijri(now.Year(), int(now.Month()), now.Day())
+			year, month = hy, hm
+		default:
+			year, month = now.Year(), int(now.Month())
+		}
+	}
+
+	cal := user.Calendar
+	cm := buildCalendarMonth(cal, year, month)
+
+	text := cm.title
+	todayKey := now.Format("2006-01-02")
+
+	hasEvent := make(map[string]bool)
+	if cal == "jalali" {
+		gy, gm, _ := jalaliToGregorian(year, month, 1)
+		lastDay := monthLenJalali(year, month)
+		gyEnd, gmEnd, gdEnd := jalaliToGregorian(year, month, lastDay)
+		startDate := fmt.Sprintf("%04d-%02d-%02d", gy, gm, 1)
+		endDate := fmt.Sprintf("%04d-%02d-%02d", gyEnd, gmEnd, gdEnd)
+		rows, err := h.DB.DB().Query(
+			"SELECT DISTINCT date FROM days WHERE user_id=? AND date >= ? AND date <= ?",
+			user.ID, startDate, endDate,
+		)
+		if err == nil {
+			for rows.Next() {
+				var d string
+				rows.Scan(&d)
+				hasEvent[d] = true
+			}
+			rows.Close()
+		}
+	} else if cal == "hijri" {
+		gy, gm, _ := hijriToGregorian(year, month, 1)
+		lastDay := monthLenHijri(year, month)
+		gyEnd, gmEnd, gdEnd := hijriToGregorian(year, month, lastDay)
+		startDate := fmt.Sprintf("%04d-%02d-%02d", gy, gm, 1)
+		endDate := fmt.Sprintf("%04d-%02d-%02d", gyEnd, gmEnd, gdEnd)
+		rows, err := h.DB.DB().Query(
+			"SELECT DISTINCT date FROM days WHERE user_id=? AND date >= ? AND date <= ?",
+			user.ID, startDate, endDate,
+		)
+		if err == nil {
+			for rows.Next() {
+				var d string
+				rows.Scan(&d)
+				hasEvent[d] = true
+			}
+			rows.Close()
+		}
+	} else {
+		startDate := fmt.Sprintf("%04d-%02d-%02d", year, month, 1)
+		endDate := fmt.Sprintf("%04d-%02d-%02d", year, month, monthLenGreg(year, month))
+		rows, err := h.DB.DB().Query(
+			"SELECT DISTINCT date FROM days WHERE user_id=? AND date >= ? AND date <= ?",
+			user.ID, startDate, endDate,
+		)
+		if err == nil {
+			for rows.Next() {
+				var d string
+				rows.Scan(&d)
+				hasEvent[d] = true
+			}
+			rows.Close()
+		}
+	}
+
+	var kbRows [][]tgbotapi.InlineKeyboardButton
+
+	var headerRow []tgbotapi.InlineKeyboardButton
+	for _, wn := range cm.weekDays {
+		headerRow = append(headerRow, tgbotapi.NewInlineKeyboardButtonData(wn, "noop"))
+	}
+	kbRows = append(kbRows, headerRow)
+
+	var row []tgbotapi.InlineKeyboardButton
+	for i, d := range cm.days {
+		if d.dayNum == 0 {
+			row = append(row, tgbotapi.NewInlineKeyboardButtonData(" ", "noop"))
+		} else {
+			label := fmt.Sprintf("%d", d.dayNum)
+			if d.date == todayKey {
+				label = fmt.Sprintf("[%d]", d.dayNum)
+			} else if hasEvent[d.date] {
+				label = fmt.Sprintf("%d*", d.dayNum)
+			}
+			row = append(row, tgbotapi.NewInlineKeyboardButtonData(label, "cal_day_"+d.date))
+		}
+		if len(row) == 7 || i == len(cm.days)-1 {
+			kbRows = append(kbRows, row)
+			row = nil
+		}
+	}
+
+	var prevY, prevM, nextY, nextM int
+	prevY, prevM = year, month-1
+	if prevM < 1 {
+		prevM = 12
+		prevY--
+	}
+	nextY, nextM = year, month+1
+	if nextM > 12 {
+		nextM = 1
+		nextY++
+	}
+
+	navRow := tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("<", fmt.Sprintf("cal_prev_%d_%d", prevY, prevM)),
+		tgbotapi.NewInlineKeyboardButtonData("Today", "history"),
+		tgbotapi.NewInlineKeyboardButtonData(">", fmt.Sprintf("cal_next_%d_%d", nextY, nextM)),
+	)
+	kbRows = append(kbRows, navRow)
+
+	kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back to Menu", "back_menu"),
+	))
+
+	kb := tgbotapi.NewInlineKeyboardMarkup(kbRows...)
+
+	if msgID == 0 {
+		reply := tgbotapi.NewMessage(chatID, text)
+		reply.ReplyMarkup = &kb
+		h.Bot.Send(reply)
+	} else {
+		edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+		edit.ReplyMarkup = &kb
+		h.Bot.Send(edit)
+	}
+}
+
+func (h *Handler) editDayView(chatID int64, msgID int, user *db.User, date string, loc *time.Location) {
+	h.sendDayView(chatID, msgID, user, date, loc, false)
+}
+
+func (h *Handler) sendDayView(chatID int64, msgID int, user *db.User, date string, loc *time.Location, isNewMsg bool) {
+	events, err := h.DB.EventsForDayByDate(user.ID, date)
+	if err != nil {
+		if isNewMsg {
+			h.sendText(chatID, "Error loading events")
+		}
+		return
+	}
+
+	text := fmt.Sprintf("Date: %s", date)
+	if len(events) == 0 {
+		text += "\nNo events for this day."
+		kb := tgbotapi.NewInlineKeyboardMarkup(
+			tgbotapi.NewInlineKeyboardRow(
+				tgbotapi.NewInlineKeyboardButtonData("Back to Calendar", "history"),
+			),
+		)
+		if isNewMsg || msgID == 0 {
+			reply := tgbotapi.NewMessage(chatID, text)
+			reply.ReplyMarkup = &kb
+			h.Bot.Send(reply)
+		} else {
+			edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+			edit.ReplyMarkup = &kb
+			h.Bot.Send(edit)
+		}
+		return
+	}
+
+	text += "\n\nEvents:"
+	var kbRows [][]tgbotapi.InlineKeyboardButton
+	for _, e := range events {
+		t := time.Unix(e.OccurredAt, 0).In(loc).Format("15:04")
+		label := "IN"
+		if e.EventType == "out" {
+			label = "OUT"
+		}
+		wt := ""
+		if e.WorkTypeID != nil {
+			if wtObj, err := h.DB.GetWorkType(*e.WorkTypeID); err == nil {
+				wt = " [" + wtObj.Name + "]"
+			}
+		}
+		note := ""
+		if e.Note != "" {
+			note = " (" + e.Note + ")"
+		}
+		text += fmt.Sprintf("\n%s %s%s%s", label, t, wt, note)
+
+		kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+			tgbotapi.NewInlineKeyboardButtonData(fmt.Sprintf("Time %s", t), fmt.Sprintf("edit_time_%d", e.ID)),
+			tgbotapi.NewInlineKeyboardButtonData("Type", fmt.Sprintf("edit_type_%d", e.ID)),
+			tgbotapi.NewInlineKeyboardButtonData("DEL", fmt.Sprintf("delete_%d", e.ID)),
+		))
+	}
+
+	kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back to Calendar", "history"),
+	))
+	kb := tgbotapi.NewInlineKeyboardMarkup(kbRows...)
+
+	if isNewMsg || msgID == 0 {
+		reply := tgbotapi.NewMessage(chatID, text)
+		reply.ReplyMarkup = &kb
+		h.Bot.Send(reply)
+	} else {
+		edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+		edit.ReplyMarkup = &kb
+		h.Bot.Send(edit)
+	}
+}
+
+func (h *Handler) editEventType(chatID int64, msgID int, user *db.User, eventID int64, loc *time.Location) {
+	wts, err := h.DB.GetWorkTypes()
+	if err != nil {
+		return
+	}
+	text := "Select new work type:"
+	var kbRows [][]tgbotapi.InlineKeyboardButton
+	for _, wt := range wts {
+		kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+			tgbotapi.NewInlineKeyboardButtonData(wt.Name, fmt.Sprintf("settype_%d_%d", eventID, wt.ID)),
+		))
+	}
+	kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back", fmt.Sprintf("back_day_%d", eventID)),
+	))
+	kb := tgbotapi.NewInlineKeyboardMarkup(kbRows...)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kb
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) setEventWorkType(chatID int64, msgID int, user *db.User, eventID, workTypeID int64, loc *time.Location) {
+	h.DB.DB().Exec("UPDATE events SET work_type_id=? WHERE id=?", workTypeID, eventID)
+	event, err := h.getEventByID(user.ID, eventID)
+	if err != nil {
+		return
+	}
+	t := time.Unix(event.OccurredAt, 0).In(loc)
+	date := t.Format("2006-01-02")
+	h.sendDayView(chatID, msgID, user, date, loc, false)
+}
+
+func (h *Handler) editEventTime(chatID int64, msgID int, user *db.User, eventID int64, loc *time.Location) {
+	text := "Select hour:"
+	var kbRows [][]tgbotapi.InlineKeyboardButton
+	var hourRow []tgbotapi.InlineKeyboardButton
+	for hh := 0; hh < 24; hh++ {
+		hourRow = append(hourRow, tgbotapi.NewInlineKeyboardButtonData(
+			fmt.Sprintf("%02d", hh),
+			fmt.Sprintf("edittm_%d_%02d", eventID, hh),
+		))
+		if len(hourRow) == 6 || hh == 23 {
+			kbRows = append(kbRows, hourRow)
+			hourRow = nil
+		}
+	}
+	kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back", fmt.Sprintf("back_day_%d", eventID)),
+	))
+	kb := tgbotapi.NewInlineKeyboardMarkup(kbRows...)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kb
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) editEventTimeMin(chatID int64, msgID int, user *db.User, eventID int64, hh int, loc *time.Location) {
+	text := fmt.Sprintf("Select minute for hour %02d:", hh)
+	var kbRows [][]tgbotapi.InlineKeyboardButton
+	var minRow []tgbotapi.InlineKeyboardButton
+	minutes := []int{0, 15, 30, 45}
+	for _, mm := range minutes {
+		minRow = append(minRow, tgbotapi.NewInlineKeyboardButtonData(
+			fmt.Sprintf("%02d", mm),
+			fmt.Sprintf("edittm_%d_%02d_%02d", eventID, hh, mm),
+		))
+	}
+	kbRows = append(kbRows, minRow)
+	kbRows = append(kbRows, tgbotapi.NewInlineKeyboardRow(
+		tgbotapi.NewInlineKeyboardButtonData("Back", fmt.Sprintf("edit_time_%d", eventID)),
+	))
+	kb := tgbotapi.NewInlineKeyboardMarkup(kbRows...)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kb
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) editEventTimeSet(chatID int64, msgID int, user *db.User, eventID int64, hh, mm int, loc *time.Location) {
+	event, err := h.getEventByID(user.ID, eventID)
+	if err != nil {
+		return
+	}
+	t := time.Unix(event.OccurredAt, 0).In(loc)
+	newTime := time.Date(t.Year(), t.Month(), t.Day(), hh, mm, 0, 0, loc)
+	date := t.Format("2006-01-02")
+
+	// Check for overlaps with adjacent events
+	events, err := h.DB.EventsForDayByDate(user.ID, date)
+	if err == nil {
+		for _, e := range events {
+			if e.ID == eventID {
+				continue
+			}
+			eTime := time.Unix(e.OccurredAt, 0)
+			if newTime.Unix() == eTime.Unix() {
+				h.acknowledgeCallback(chatID, msgID)
+				h.sendDayView(chatID, msgID, user, date, loc, false)
+				return
+			}
+		}
+		type eventPos struct {
+			id  int64
+			typ string
+			t   int64
+		}
+		var sorted []eventPos
+		for _, e := range events {
+			et := e.OccurredAt
+			if e.ID == eventID {
+				et = newTime.Unix()
+			}
+			sorted = append(sorted, eventPos{e.ID, e.EventType, et})
+		}
+		for i := 0; i < len(sorted); i++ {
+			for j := i + 1; j < len(sorted); j++ {
+				if sorted[j].t < sorted[i].t || (sorted[j].t == sorted[i].t && sorted[j].id < sorted[i].id) {
+					sorted[i], sorted[j] = sorted[j], sorted[i]
+				}
+			}
+		}
+		for i := 1; i < len(sorted); i++ {
+			if sorted[i].typ == sorted[i-1].typ {
+				text := "Edit rejected: overlapping events. Two consecutive events must be different types (in/out)."
+				edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+				h.Bot.Send(edit)
+				return
+			}
+		}
+	}
+
+	h.DB.DB().Exec("UPDATE events SET occurred_at=? WHERE id=?", newTime.Unix(), eventID)
+	h.sendDayView(chatID, msgID, user, date, loc, false)
+}
+
+func (h *Handler) acknowledgeCallback(chatID int64, msgID int) {
+	h.Bot.Request(tgbotapi.NewCallback(fmt.Sprintf("cb_%d_%d", chatID, msgID), ""))
+}
+
+func (h *Handler) deleteEventPrompt(chatID int64, msgID int, user *db.User, eventID int64, loc *time.Location) {
+	text := "Delete this event?"
+	kbRows := tgbotapi.NewInlineKeyboardMarkup(
+		tgbotapi.NewInlineKeyboardRow(
+			tgbotapi.NewInlineKeyboardButtonData("Yes, DEL", fmt.Sprintf("delconf_%d", eventID)),
+			tgbotapi.NewInlineKeyboardButtonData("Cancel", fmt.Sprintf("back_day_%d", eventID)),
+		),
+	)
+	edit := tgbotapi.NewEditMessageText(chatID, msgID, text)
+	edit.ReplyMarkup = &kbRows
+	h.Bot.Send(edit)
+}
+
+func (h *Handler) deleteEventConfirm(chatID int64, msgID int, user *db.User, eventID int64, loc *time.Location) {
+	event, err := h.getEventByID(user.ID, eventID)
+	if err != nil {
+		return
+	}
+	t := time.Unix(event.OccurredAt, 0).In(loc)
+	date := t.Format("2006-01-02")
+
+	h.DB.DB().Exec("DELETE FROM events WHERE id=?", eventID)
+
+	// Check if remaining events need repair
+	events, err := h.DB.EventsForDayByDate(user.ID, date)
+	if err == nil && len(events) > 1 {
+		var hasIssue bool
+		for i := 1; i < len(events); i++ {
+			if events[i].EventType == events[i-1].EventType {
+				hasIssue = true
+				break
+			}
+		}
+		if hasIssue {
+			h.sendText(chatID, "Warning: Timeline has consecutive events of same type after deletion. Timeline requires manual repair.")
+		}
+	}
+
+	h.sendDayView(chatID, msgID, user, date, loc, false)
+}
+
+func (h *Handler) backToDayView(chatID int64, msgID int, user *db.User, eventID int64, loc *time.Location) {
+	event, err := h.getEventByID(user.ID, eventID)
+	if err != nil {
+		return
+	}
+	t := time.Unix(event.OccurredAt, 0).In(loc)
+	date := t.Format("2006-01-02")
+	h.sendDayView(chatID, msgID, user, date, loc, false)
+}
+
+func (h *Handler) getEventByID(userID, eventID int64) (*db.Event, error) {
+	row := h.DB.DB().QueryRow(
+		"SELECT id, user_id, day_id, event_type, work_type_id, occurred_at, note, created_at FROM events WHERE id=? AND user_id=?",
+		eventID, userID,
+	)
+	var e db.Event
+	var wt sql.NullInt64
+	if err := row.Scan(&e.ID, &e.UserID, &e.DayID, &e.EventType, &wt, &e.OccurredAt, &e.Note, &e.CreatedAt); err != nil {
+		return nil, err
+	}
+	if wt.Valid {
+		e.WorkTypeID = &wt.Int64
+	}
+	return &e, nil
+}
+
 func (h *Handler) handleExport(msg *tgbotapi.Message) {
 	user, err := h.getOrCreateUser(msg.Chat.ID)
 	if err != nil {
@@ -550,7 +1181,7 @@ func (h *Handler) handleExport(msg *tgbotapi.Message) {
 	}
 	now := time.Now()
 	slog.Info("export", "user_id", user.ID, "year", now.Year(), "month", now.Month())
-	data, err := GenerateMonthlyReport(h.DB, user.ID, user.Timezone, user.ExportAccent, now.Year(), now.Month())
+	data, err := GenerateMonthlyReport(h.DB, user.ID, user.Timezone, user.ExportAccent, user.Calendar, now.Year(), now.Month())
 	if err != nil {
 		slog.Error("generate report", "error", err)
 		h.sendText(msg.Chat.ID, "Error generating report")
@@ -578,7 +1209,7 @@ func (h *Handler) exportCallback(chatID int64, msgID int, callbackID string) {
 	}
 	now := time.Now()
 	slog.Info("export", "user_id", user.ID, "year", now.Year(), "month", now.Month())
-	data, err := GenerateMonthlyReport(h.DB, user.ID, user.Timezone, user.ExportAccent, now.Year(), now.Month())
+	data, err := GenerateMonthlyReport(h.DB, user.ID, user.Timezone, user.ExportAccent, user.Calendar, now.Year(), now.Month())
 	if err != nil {
 		slog.Error("generate report", "error", err)
 		edit := tgbotapi.NewEditMessageText(chatID, msgID, "Error generating report")
@@ -630,7 +1261,12 @@ func (h *Handler) buildStatusText(chatID int64) string {

 	events, err := h.DB.EventsForDayByDayID(day.ID)
 	if err == nil && len(events) > 0 {
-		totals := ComputeDailyTotals(events, day.MinBreakThreshold)
+		loc, _ := time.LoadLocation(user.Timezone)
+		now := time.Now().In(loc)
+		y, m, d := now.Date()
+		dayStart := time.Date(y, m, d, 0, 0, 0, 0, loc).Unix()
+		dayEnd := now.Unix()
+		totals := ComputeDailyTotals(events, day.MinBreakThreshold, dayStart, dayEnd)
 		text += fmt.Sprintf("\nToday: %s worked", formatDuration(totals.TotalSeconds))
 	}

@@ -660,7 +1296,10 @@ func (h *Handler) buildDailyReport(user *db.User, day *db.Day, events []db.Event
 		return fmt.Sprintf("%s - No events recorded.", day.Date)
 	}

-	totals := ComputeDailyTotals(events, day.MinBreakThreshold)
+	y, m, d := parseGregorianDateKey(day.Date)
+	dayStart := time.Date(y, time.Month(m), d, 0, 0, 0, 0, loc).Unix()
+	dayEnd := time.Date(y, time.Month(m), d, 23, 59, 59, 0, loc).Unix()
+	totals := ComputeDailyTotals(events, day.MinBreakThreshold, dayStart, dayEnd)
 	lines := fmt.Sprintf("Report for %s", day.Date)
 	if day.IsDayOff {
 		lines += "\nDay Off: Yes"