package dailyreport

import (
	"encoding/json"
	"fmt"
	"strings"
	"time"
	"unicode/utf8"

	"server/models"

	"github.com/beego/beego/v2/client/orm"
)

// Attachment 日报附件，与 PC / 小程序上传接口返回的文件信息对齐。
type Attachment struct {
	ID   uint64 `json:"id"`
	URL  string `json:"url"`
	Name string `json:"name"`
	Size int64  `json:"size"`
}

// ReportItem 日报列表/详情中的主体。
type ReportItem struct {
	ID           uint64       `json:"id"`
	UserID       uint64       `json:"user_id"`
	UserName     string       `json:"user_name"`
	OrgID        uint64       `json:"org_id"`
	OrgName      string       `json:"org_name"`
	ReportDate   string       `json:"report_date"`
	TodayDone    string       `json:"today_done"`
	TomorrowPlan string       `json:"tomorrow_plan"`
	Issues       string       `json:"issues"`
	Attachments  []Attachment `json:"attachments"`
	Status       int8         `json:"status"`
	SubmitTime   string       `json:"submit_time"`
	CreateTime   string       `json:"create_time"`
	UpdateTime   string       `json:"update_time"`
	CommentCount int          `json:"comment_count"`
}

// Comment 日报评论（两级回复）。
type Comment struct {
	ID          uint64 `json:"id"`
	UserID      uint64 `json:"user_id"`
	UserName    string `json:"user_name"`
	Content     string `json:"content"`
	ReplyToID   uint64 `json:"reply_to_id"`
	ReplyToName string `json:"reply_to_name"`
	CreateTime  string `json:"create_time"`
	IsMine      bool   `json:"is_mine"`
	CanDelete   bool   `json:"can_delete"`
}

// Detail 日报详情：主体 + 评论 + 修改痕迹 + 当前用户可执行的操作。
type Detail struct {
	Report      ReportItem    `json:"report"`
	Comments    []Comment     `json:"comments"`
	Histories   []HistoryItem `json:"histories"`
	IsAuthor    bool          `json:"is_author"`
	CanEdit     bool          `json:"can_edit"`
	CanDelete   bool          `json:"can_delete"`
	CanComment  bool          `json:"can_comment"`
	CanWithdraw bool          `json:"can_withdraw"`
}

// HistoryItem 日报修改痕迹：撤销提交 / 撤销后重新提交时的内容快照。
type HistoryItem struct {
	ID           uint64       `json:"id"`
	Action       int8         `json:"action"` // 1撤销提交 2重新提交
	UserName     string       `json:"user_name"`
	TodayDone    string       `json:"today_done"`
	TomorrowPlan string       `json:"tomorrow_plan"`
	Issues       string       `json:"issues"`
	Attachments  []Attachment `json:"attachments"`
	SubmitTime   string       `json:"submit_time"`
	CreateTime   string       `json:"create_time"`
}

// SaveInput 保存日报入参；Submit=true 表示提交，否则保存草稿。
type SaveInput struct {
	Date         string `json:"date"`
	TodayDone    string `json:"today_done"`
	TomorrowPlan string `json:"tomorrow_plan"`
	Issues       string `json:"issues"`
	Attachments  string `json:"attachments"`
	Submit       bool   `json:"submit"`
}

// MineQuery 我的日报列表查询。
type MineQuery struct {
	StartDate string
	EndDate   string
	Page      int
	PageSize  int
}

// MineSummary 我的日报页头统计。
type MineSummary struct {
	MonthTotal     int    `json:"month_total"`
	MonthSubmitted int    `json:"month_submitted"`
	TodayStatus    int8   `json:"today_status"` // -1=今天未填写
	TodayReportID  uint64 `json:"today_report_id"`
	WindowStart    string `json:"window_start"`
	WindowEnd      string `json:"window_end"`
}

// MineResult 我的日报列表结果。
type MineResult struct {
	List    []ReportItem `json:"list"`
	Total   int64        `json:"total"`
	Summary MineSummary  `json:"summary"`
}

// Save 新建或更新一条日报（同一人同一天唯一）。
// 已提交的日报处于锁定状态，必须先撤销提交退回草稿才能修改。
func Save(u *UserContext, in SaveInput) (*ReportItem, error) {
	date, err := ParseDate(in.Date)
	if err != nil {
		return nil, err
	}
	if !InWindow(date) {
		return nil, errBad(fmt.Sprintf("只能补写最近%d天（%s 至 %s）的日报", BackfillDays, WindowStart(), Today()))
	}

	in.TodayDone = strings.TrimSpace(in.TodayDone)
	in.TomorrowPlan = strings.TrimSpace(in.TomorrowPlan)
	in.Issues = strings.TrimSpace(in.Issues)
	for name, text := range map[string]string{
		"今日完成":  in.TodayDone,
		"明日计划":  in.TomorrowPlan,
		"问题与建议": in.Issues,
	} {
		if utf8.RuneCountInString(text) > 5000 {
			return nil, errBad(name + "不能超过5000字")
		}
	}
	if in.TodayDone == "" && in.TomorrowPlan == "" && in.Issues == "" {
		return nil, errBad("请至少填写今日完成、明日计划、问题与建议中的一项")
	}
	attachmentJSON, _, err := normalizeAttachments(in.Attachments)
	if err != nil {
		return nil, err
	}

	var existing models.OaDailyReport
	findErr := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).
		Filter("user_id", u.UID).
		Filter("report_date", date).
		Filter("is_deleted", 0).
		One(&existing)

	status := int8(0)
	if in.Submit {
		status = 1
	}
	now := time.Now()

	if findErr == orm.ErrNoRows {
		report := models.OaDailyReport{
			Tid:          u.Tid,
			UserID:       u.UID,
			UserName:     u.Name,
			OrgID:        u.OrgID,
			OrgName:      u.OrgName,
			ReportDate:   date,
			TodayDone:    in.TodayDone,
			TomorrowPlan: in.TomorrowPlan,
			Issues:       in.Issues,
			Attachments:  attachmentJSON,
			Status:       status,
		}
		if status == 1 {
			report.SubmitTime = &now
		}
		if _, err := models.Orm.Insert(&report); err != nil {
			return nil, errBad("保存失败，该日期可能已存在日报，请刷新后重试")
		}
		return buildItem(&report, 0), nil
	}
	if findErr != nil {
		return nil, findErr
	}

	// 已提交的日报锁定：必须先撤销提交退回草稿，才能修改内容。
	if existing.Status == 1 {
		return nil, errBad("日报已提交并锁定，如需修改请先撤销提交")
	}
	// 撤销过提交的日报再次提交时，留下重新提交痕迹。
	resubmit := false
	if in.Submit {
		if existing.SubmitTime != nil {
			resubmit = true
		} else {
			resubmit = hasWithdrawHistory(u.Tid, existing.ID)
		}
		existing.SubmitTime = &now
	}
	existing.TodayDone = in.TodayDone
	existing.TomorrowPlan = in.TomorrowPlan
	existing.Issues = in.Issues
	existing.Attachments = attachmentJSON
	existing.Status = status
	existing.UserName = u.Name
	existing.OrgID = u.OrgID
	existing.OrgName = u.OrgName

	tx, err := models.Orm.Begin()
	if err != nil {
		return nil, err
	}
	if _, err := tx.Update(&existing, "today_done", "tomorrow_plan", "issues",
		"attachments", "status", "submit_time", "user_name", "org_id", "org_name"); err != nil {
		_ = tx.Rollback()
		return nil, err
	}
	if resubmit {
		history := models.OaDailyReportHistory{
			Tid:          u.Tid,
			ReportID:     existing.ID,
			UserID:       u.UID,
			UserName:     u.Name,
			ReportDate:   date,
			Action:       2,
			TodayDone:    existing.TodayDone,
			TomorrowPlan: existing.TomorrowPlan,
			Issues:       existing.Issues,
			Attachments:  existing.Attachments,
			SubmitTime:   existing.SubmitTime,
		}
		if _, err := tx.Insert(&history); err != nil {
			_ = tx.Rollback()
			return nil, err
		}
	}
	if err := tx.Commit(); err != nil {
		return nil, err
	}
	count := commentCount(u.Tid, existing.ID)
	return buildItem(&existing, count), nil
}

// ListMine 我的日报分页列表 + 页头统计。
func ListMine(u *UserContext, q MineQuery) (*MineResult, error) {
	if q.Page < 1 {
		q.Page = 1
	}
	if q.PageSize < 1 || q.PageSize > 100 {
		q.PageSize = 20
	}

	base := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).
		Filter("user_id", u.UID).
		Filter("is_deleted", 0)

	start, err := optionalDate(q.StartDate)
	if err != nil {
		return nil, err
	}
	end, err := optionalDate(q.EndDate)
	if err != nil {
		return nil, err
	}
	if start != "" {
		base = base.Filter("report_date__gte", start)
	}
	if end != "" {
		base = base.Filter("report_date__lte", end)
	}

	total, _ := base.Count()
	var rows []models.OaDailyReport
	if _, err := base.OrderBy("-report_date", "-id").
		Limit(q.PageSize).Offset((q.Page - 1) * q.PageSize).
		All(&rows); err != nil {
		return nil, err
	}

	ids := make([]uint64, 0, len(rows))
	for i := range rows {
		ids = append(ids, rows[i].ID)
	}
	counts := commentCounts(u.Tid, ids)

	list := make([]ReportItem, 0, len(rows))
	for i := range rows {
		list = append(list, *buildItem(&rows[i], counts[rows[i].ID]))
	}

	summary, err := mineSummary(u)
	if err != nil {
		return nil, err
	}
	return &MineResult{List: list, Total: total, Summary: *summary}, nil
}

// CalendarDay 我的日报日历热力图单日状态。
type CalendarDay struct {
	Date   string `json:"date"`
	Status int8   `json:"status"` // 0草稿 1已提交
	ID     uint64 `json:"id"`
}

// CalendarResult 近期热力图数据（默认近三个月）。
type CalendarResult struct {
	StartDate string        `json:"start_date"`
	EndDate   string        `json:"end_date"`
	Total     int           `json:"total"`
	Submitted int           `json:"submitted"`
	Days      []CalendarDay `json:"days"`
}

// Calendar 返回最近 months 个月（含本月）本人日报的逐日状态，供热力图按月/周渲染。
// months 越界时回落到 3 个月。
func Calendar(u *UserContext, months int) (*CalendarResult, error) {
	if months < 1 || months > 12 {
		months = 3
	}
	now := time.Now()
	monthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
	start := monthStart.AddDate(0, -(months - 1), 0)
	end := monthStart.AddDate(0, 1, -1)
	startDate := start.Format("2006-01-02")
	endDate := end.Format("2006-01-02")

	var rows []models.OaDailyReport
	if _, err := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).
		Filter("user_id", u.UID).
		Filter("is_deleted", 0).
		Filter("report_date__gte", startDate).
		Filter("report_date__lte", endDate).
		OrderBy("report_date").
		All(&rows, "id", "report_date", "status"); err != nil {
		return nil, err
	}
	res := &CalendarResult{
		StartDate: startDate,
		EndDate:   endDate,
		Days:      make([]CalendarDay, 0, len(rows)),
	}
	for i := range rows {
		res.Days = append(res.Days, CalendarDay{
			// DATE 列在 parseTime=true 下会带上时间与时区，必须归一化为 YYYY-MM-DD，
			// 否则前端按日期匹配热力图格子时永远匹配不到。
			Date:   dateOnly(rows[i].ReportDate),
			Status: rows[i].Status,
			ID:     rows[i].ID,
		})
		if rows[i].Status == 1 {
			res.Submitted++
		}
	}
	res.Total = len(rows)
	return res, nil
}

// mineSummary 本月提交统计与今天的状态。
func mineSummary(u *UserContext) (*MineSummary, error) {
	now := time.Now()
	monthStart := now.Format("2006-01") + "-01"
	monthEnd := now.AddDate(0, 1, -1).Format("2006-01-02")

	out := &MineSummary{
		TodayStatus: -1,
		WindowStart: WindowStart(),
		WindowEnd:   Today(),
	}
	base := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).
		Filter("user_id", u.UID).
		Filter("is_deleted", 0)
	out.MonthTotal = int(countWhere(base, "report_date__gte", monthStart, "report_date__lte", monthEnd))
	out.MonthSubmitted = int(countWhere(base.Filter("status", 1), "report_date__gte", monthStart, "report_date__lte", monthEnd))

	var today models.OaDailyReport
	if err := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).Filter("user_id", u.UID).
		Filter("report_date", Today()).
		Filter("is_deleted", 0).One(&today); err == nil {
		out.TodayStatus = today.Status
		out.TodayReportID = today.ID
	}
	return out, nil
}

// GetDetail 读取日报详情；无权限时返回 403。
func GetDetail(u *UserContext, id uint64) (*Detail, error) {
	report, err := loadReport(u.Tid, id)
	if err != nil {
		return nil, err
	}
	if !canViewReport(u, report) {
		return nil, errForbidden("无权查看该日报")
	}

	comments := make([]Comment, 0)
	if report.Status == 1 {
		comments, err = loadComments(u, report.ID)
		if err != nil {
			return nil, err
		}
	}

	author := report.UserID == u.UID
	canEdit := author && report.Status == 0 && InWindow(report.ReportDate)
	canWithdraw := author && report.Status == 1 && InWindow(report.ReportDate)
	// 删除仅限草稿：已提交日报需先撤销提交才能删除。
	canDelete := report.Status == 0 && (u.IsAdmin || (author && InWindow(report.ReportDate)))

	// 修改痕迹只对作者本人与租户管理员可见。
	histories := make([]HistoryItem, 0)
	if author || u.IsAdmin {
		histories, err = loadHistories(u.Tid, report.ID)
		if err != nil {
			// 痕迹表缺失或查询异常时降级为空，避免详情整体 500（部署时需执行 create_oa_dailyreport_history.sql）。
			histories = make([]HistoryItem, 0)
		}
	}
	return &Detail{
		Report:      *buildItem(report, len(comments)),
		Comments:    comments,
		Histories:   histories,
		IsAuthor:    author,
		CanEdit:     canEdit,
		CanDelete:   canDelete,
		CanComment:  report.Status == 1 && (author || u.IsAdmin || u.InTeamOrg(report.OrgID)),
		CanWithdraw: canWithdraw,
	}, nil
}

// Withdraw 撤销提交：把已提交日报退回草稿，并把本次提交的内容快照写入修改痕迹。
// 仅作者本人、且日报在补写窗口内时可操作；撤销后需修改并重新提交。
func Withdraw(u *UserContext, id uint64) (*ReportItem, error) {
	report, err := loadReport(u.Tid, id)
	if err != nil {
		return nil, err
	}
	if report.UserID != u.UID {
		return nil, errForbidden("只能撤销自己提交的日报")
	}
	if report.Status != 1 {
		return nil, errBad("日报尚未提交，无需撤销")
	}
	if !InWindow(report.ReportDate) {
		return nil, errBad(fmt.Sprintf("只能撤销最近%d天（%s 至 %s）的日报", BackfillDays, WindowStart(), Today()))
	}

	tx, err := models.Orm.Begin()
	if err != nil {
		return nil, err
	}
	history := models.OaDailyReportHistory{
		Tid:          u.Tid,
		ReportID:     report.ID,
		UserID:       u.UID,
		UserName:     u.Name,
		ReportDate:   report.ReportDate,
		Action:       1,
		TodayDone:    report.TodayDone,
		TomorrowPlan: report.TomorrowPlan,
		Issues:       report.Issues,
		Attachments:  report.Attachments,
		SubmitTime:   report.SubmitTime,
	}
	if _, err := tx.Insert(&history); err != nil {
		_ = tx.Rollback()
		return nil, err
	}
	if _, err := tx.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).Filter("id", report.ID).
		Update(map[string]interface{}{"status": 0, "submit_time": nil}); err != nil {
		_ = tx.Rollback()
		return nil, err
	}
	if err := tx.Commit(); err != nil {
		return nil, err
	}

	report.Status = 0
	count := commentCount(u.Tid, report.ID)
	return buildItem(report, count), nil
}

// Delete 软删除日报及其评论：作者限补写窗口内，管理员不受限。
//
// 日报的 is_deleted 写入记录 ID（而非 1），既标记删除，又让唯一键
// (tid, user_id, report_date, is_deleted) 在「删除后同一天重新填写」时不冲突。
func Delete(u *UserContext, id uint64) error {
	report, err := loadReport(u.Tid, id)
	if err != nil {
		return err
	}
	// 已提交日报锁定：不允许直接删除，需先撤销提交退回草稿。
	if report.Status == 1 {
		return errBad("日报已提交并锁定，请先撤销提交后再删除")
	}
	author := report.UserID == u.UID
	if !author && !u.IsAdmin {
		return errForbidden("无权删除该日报")
	}
	if author && !u.IsAdmin && !InWindow(report.ReportDate) {
		return errBad(fmt.Sprintf("只能删除最近%d天（%s 至 %s）的日报", BackfillDays, WindowStart(), Today()))
	}

	now := time.Now()
	tx, err := models.Orm.Begin()
	if err != nil {
		return err
	}
	if _, err := tx.QueryTable(new(models.OaDailyReportComment)).
		Filter("tid", u.Tid).Filter("report_id", report.ID).Filter("is_deleted", 0).
		Update(map[string]interface{}{"is_deleted": 1, "delete_time": now}); err != nil {
		_ = tx.Rollback()
		return err
	}
	if _, err := tx.QueryTable(new(models.OaDailyReport)).
		Filter("tid", u.Tid).Filter("id", report.ID).
		Update(map[string]interface{}{"is_deleted": report.ID, "delete_time": now}); err != nil {
		_ = tx.Rollback()
		return err
	}
	return tx.Commit()
}

// AddComment 对已提交日报发表评论或回复；replyToID=0 表示直接评论。
func AddComment(u *UserContext, reportID uint64, content string, replyToID uint64) (*Comment, error) {
	content = strings.TrimSpace(content)
	if content == "" {
		return nil, errBad("请输入评论内容")
	}
	if utf8.RuneCountInString(content) > 1000 {
		return nil, errBad("评论不能超过1000字")
	}
	report, err := loadReport(u.Tid, reportID)
	if err != nil {
		return nil, err
	}
	if !canViewReport(u, report) {
		return nil, errForbidden("无权评论该日报")
	}
	if report.Status != 1 {
		return nil, errBad("日报提交后才能评论")
	}

	replyName := ""
	if replyToID > 0 {
		var parent models.OaDailyReportComment
		if err := models.Orm.QueryTable(new(models.OaDailyReportComment)).
			Filter("tid", u.Tid).Filter("id", replyToID).Filter("report_id", reportID).
			Filter("is_deleted", 0).
			One(&parent); err != nil {
			return nil, errBad("回复的评论不存在")
		}
		replyName = parent.UserName
	}

	row := models.OaDailyReportComment{
		Tid:         u.Tid,
		ReportID:    reportID,
		UserID:      u.UID,
		UserName:    u.Name,
		Content:     content,
		ReplyToID:   replyToID,
		ReplyToName: replyName,
	}
	if _, err := models.Orm.Insert(&row); err != nil {
		return nil, err
	}
	c := buildComment(u, &row)
	return &c, nil
}

// DeleteComment 软删除评论：评论作者本人或管理员。
func DeleteComment(u *UserContext, commentID uint64) error {
	var row models.OaDailyReportComment
	if err := models.Orm.QueryTable(new(models.OaDailyReportComment)).
		Filter("tid", u.Tid).Filter("id", commentID).Filter("is_deleted", 0).One(&row); err != nil {
		return errNotFound("评论不存在或已删除")
	}
	if row.UserID != u.UID && !u.IsAdmin {
		return errForbidden("只能删除自己的评论")
	}
	_, err := models.Orm.QueryTable(new(models.OaDailyReportComment)).
		Filter("tid", u.Tid).Filter("id", commentID).Filter("is_deleted", 0).
		Update(map[string]interface{}{"is_deleted": 1, "delete_time": time.Now()})
	return err
}

// ========================== 内部工具 ==========================

func loadReport(tid, id uint64) (*models.OaDailyReport, error) {
	var report models.OaDailyReport
	if err := models.Orm.QueryTable(new(models.OaDailyReport)).
		Filter("tid", tid).Filter("id", id).Filter("is_deleted", 0).One(&report); err != nil {
		if err == orm.ErrNoRows {
			return nil, errNotFound("日报不存在或已删除")
		}
		return nil, err
	}
	// 统一成 YYYY-MM-DD，保证 InWindow 与前端日期比较正确。
	report.ReportDate = dateOnly(report.ReportDate)
	return &report, nil
}

// canViewReport 本人 / 管理员 / 作者所在部门的主管；草稿仅本人与管理员可见。
func canViewReport(u *UserContext, r *models.OaDailyReport) bool {
	if r.UserID == u.UID || u.IsAdmin {
		return true
	}
	if r.Status != 1 {
		return false
	}
	return u.InTeamOrg(r.OrgID)
}

func loadComments(u *UserContext, reportID uint64) ([]Comment, error) {
	var rows []models.OaDailyReportComment
	if _, err := models.Orm.QueryTable(new(models.OaDailyReportComment)).
		Filter("tid", u.Tid).Filter("report_id", reportID).
		Filter("is_deleted", 0).
		OrderBy("id").All(&rows); err != nil {
		return nil, err
	}
	out := make([]Comment, 0, len(rows))
	for i := range rows {
		out = append(out, buildComment(u, &rows[i]))
	}
	if out == nil {
		out = []Comment{}
	}
	return out, nil
}

func buildComment(u *UserContext, r *models.OaDailyReportComment) Comment {
	return Comment{
		ID:          r.ID,
		UserID:      r.UserID,
		UserName:    r.UserName,
		Content:     r.Content,
		ReplyToID:   r.ReplyToID,
		ReplyToName: r.ReplyToName,
		CreateTime:  r.CreateTime.Format("2006-01-02 15:04"),
		IsMine:      r.UserID == u.UID,
		CanDelete:   r.UserID == u.UID || u.IsAdmin,
	}
}

// hasWithdrawHistory 判断一条日报是否被撤销过提交，用于识别“重新提交”。
func hasWithdrawHistory(tid, reportID uint64) bool {
	n, err := models.Orm.QueryTable(new(models.OaDailyReportHistory)).
		Filter("tid", tid).Filter("report_id", reportID).Filter("action", 1).
		Count()
	return err == nil && n > 0
}

// loadHistories 读取一条日报的全部修改痕迹，按写入顺序返回。
func loadHistories(tid, reportID uint64) ([]HistoryItem, error) {
	var rows []models.OaDailyReportHistory
	if _, err := models.Orm.QueryTable(new(models.OaDailyReportHistory)).
		Filter("tid", tid).Filter("report_id", reportID).
		OrderBy("id").All(&rows); err != nil {
		return nil, err
	}
	out := make([]HistoryItem, 0, len(rows))
	for i := range rows {
		out = append(out, buildHistory(&rows[i]))
	}
	return out, nil
}

func buildHistory(h *models.OaDailyReportHistory) HistoryItem {
	attachments := make([]Attachment, 0)
	if strings.TrimSpace(h.Attachments) != "" {
		_ = json.Unmarshal([]byte(h.Attachments), &attachments)
	}
	return HistoryItem{
		ID:           h.ID,
		Action:       h.Action,
		UserName:     h.UserName,
		TodayDone:    h.TodayDone,
		TomorrowPlan: h.TomorrowPlan,
		Issues:       h.Issues,
		Attachments:  attachments,
		SubmitTime:   formatTime(h.SubmitTime),
		CreateTime:   h.CreateTime.Format("2006-01-02 15:04"),
	}
}

func buildItem(r *models.OaDailyReport, commentCount int) *ReportItem {
	attachments := make([]Attachment, 0)
	if strings.TrimSpace(r.Attachments) != "" {
		_ = json.Unmarshal([]byte(r.Attachments), &attachments)
	}
	return &ReportItem{
		ID:           r.ID,
		UserID:       r.UserID,
		UserName:     r.UserName,
		OrgID:        r.OrgID,
		OrgName:      r.OrgName,
		ReportDate:   dateOnly(r.ReportDate),
		TodayDone:    r.TodayDone,
		TomorrowPlan: r.TomorrowPlan,
		Issues:       r.Issues,
		Attachments:  attachments,
		Status:       r.Status,
		SubmitTime:   formatTime(r.SubmitTime),
		CreateTime:   r.CreateTime.Format("2006-01-02 15:04"),
		UpdateTime:   formatTime(r.UpdateTime),
		CommentCount: commentCount,
	}
}

func formatTime(t *time.Time) string {
	if t == nil || t.IsZero() {
		return ""
	}
	return t.Format("2006-01-02 15:04")
}

// normalizeAttachments 校验并规范化附件 JSON，最多 20 个。
func normalizeAttachments(raw string) (string, []Attachment, error) {
	raw = strings.TrimSpace(raw)
	if raw == "" || raw == "null" {
		return "[]", []Attachment{}, nil
	}
	var items []Attachment
	if err := json.Unmarshal([]byte(raw), &items); err != nil {
		return "", nil, errBad("附件数据格式错误")
	}
	out := make([]Attachment, 0, len(items))
	for _, it := range items {
		if strings.TrimSpace(it.URL) == "" {
			continue
		}
		if len(out) >= 20 {
			return "", nil, errBad("附件最多20个")
		}
		out = append(out, it)
	}
	data, _ := json.Marshal(out)
	return string(data), out, nil
}

func optionalDate(v string) (string, error) {
	v = strings.TrimSpace(v)
	if v == "" {
		return "", nil
	}
	return ParseDate(v)
}

// countWhere 依次应用列值条件后计数。
func countWhere(qs orm.QuerySeter, kv ...string) int64 {
	for i := 0; i+1 < len(kv); i += 2 {
		qs = qs.Filter(kv[i], kv[i+1])
	}
	n, _ := qs.Count()
	return n
}

func commentCount(tid, reportID uint64) int {
	counts := commentCounts(tid, []uint64{reportID})
	return counts[reportID]
}

// commentCounts 批量统计评论数，避免列表逐条查询。
func commentCounts(tid uint64, ids []uint64) map[uint64]int {
	out := make(map[uint64]int, len(ids))
	if len(ids) == 0 {
		return out
	}
	holders := make([]string, 0, len(ids))
	args := make([]interface{}, 0, len(ids)+1)
	args = append(args, tid)
	for _, id := range ids {
		holders = append(holders, "?")
		args = append(args, id)
	}
	var rows []struct {
		ReportID uint64 `orm:"column(report_id)"`
		Cnt      int    `orm:"column(cnt)"`
	}
	sql := "SELECT report_id, COUNT(*) AS cnt FROM yz_backend_oa_daily_report_comment" +
		" WHERE tid = ? AND report_id IN (" + strings.Join(holders, ",") + ") AND is_deleted = 0 GROUP BY report_id"
	if _, err := models.Orm.Raw(sql, args...).QueryRows(&rows); err != nil {
		return out
	}
	for _, r := range rows {
		out[r.ReportID] = r.Cnt
	}
	return out
}