paliad/internal/services/fristenrechner.go

package services

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"time"
)

// FristenrechnerService renders the Paliad public Fristenrechner's response
// shape from DB-stored rules. It sits on top of DeadlineRuleService and
// HolidayService and produces the bilingual, rule-code + notes-rich payload
// that /tools/fristenrechner's client expects.
//
// The UI-facing response is distinct from the plain calculator in
// DeadlineCalculator: it adds IsRootEvent, IsCourtSet, RuleRef, Notes,
// party color classes, and keeps the result ordered by sequence_order
// within each proceeding type.
type FristenrechnerService struct {
	rules    *DeadlineRuleService
	holidays *HolidayService
}

// NewFristenrechnerService wires the service to its dependencies.
func NewFristenrechnerService(rules *DeadlineRuleService, holidays *HolidayService) *FristenrechnerService {
	return &FristenrechnerService{rules: rules, holidays: holidays}
}

// UIDeadline matches the frontend's CalculatedDeadline TypeScript interface
// (camelCase JSON to keep /tools/fristenrechner byte-identical).
type UIDeadline struct {
	Code         string `json:"code"`
	Name         string `json:"name"`
	NameEN       string `json:"nameEN"`
	Party        string `json:"party"`
	IsMandatory  bool   `json:"isMandatory"`
	RuleRef      string `json:"ruleRef"`
	Notes        string `json:"notes,omitempty"`
	DueDate      string `json:"dueDate"`
	OriginalDate string `json:"originalDate"`
	WasAdjusted  bool   `json:"wasAdjusted"`
	IsRootEvent  bool   `json:"isRootEvent"`
	IsCourtSet   bool   `json:"isCourtSet"`
}

// UIResponse matches the frontend's DeadlineResponse TypeScript interface.
type UIResponse struct {
	ProceedingType string       `json:"proceedingType"`
	ProceedingName string       `json:"proceedingName"`
	TriggerDate    string       `json:"triggerDate"`
	Deadlines      []UIDeadline `json:"deadlines"`
}

// ErrUnknownProceedingType is returned when the UI sends an unrecognised code.
var ErrUnknownProceedingType = errors.New("unknown proceeding type")

// Calculate renders the full UI timeline for a proceeding type + trigger date.
// Preserves the pre-Phase-C in-memory calculator's classification:
//
//   - Rules with duration_value = 0 and no parent_id → IsRootEvent
//     (due date = trigger date)
//   - Rules with duration_value = 0 and a parent_id → IsCourtSet
//     (due date empty, UI shows "court-set" placeholder)
//   - All other rules → calculate from either the trigger date (no parent)
//     or the previously-computed date for their parent rule.
func (s *FristenrechnerService) Calculate(ctx context.Context, proceedingCode, triggerDateStr string) (*UIResponse, error) {
	triggerDate, err := time.Parse("2006-01-02", triggerDateStr)
	if err != nil {
		return nil, fmt.Errorf("invalid trigger date %q: %w", triggerDateStr, err)
	}

	// Look up proceeding type metadata.
	var pt struct {
		ID       int    `db:"id"`
		Code     string `db:"code"`
		Name     string `db:"name"`
		NameEN   string `db:"name_en"`
	}
	err = s.rules.db.GetContext(ctx, &pt,
		`SELECT id, code, name, name_en
		   FROM paliad.proceeding_types
		  WHERE code = $1 AND is_active = true`, proceedingCode)
	if errors.Is(err, sql.ErrNoRows) {
		return nil, ErrUnknownProceedingType
	}
	if err != nil {
		return nil, fmt.Errorf("resolve proceeding %q: %w", proceedingCode, err)
	}

	rules, err := s.rules.List(ctx, &pt.ID)
	if err != nil {
		return nil, err
	}

	// Walk the rule list in sequence_order (already sorted by the query) and
	// compute each entry, keeping a code→date map so RelativeTo / parent_id
	// references resolve to the adjusted predecessor date.
	computed := make(map[string]time.Time, len(rules))
	deadlines := make([]UIDeadline, 0, len(rules))

	for _, r := range rules {
		d := UIDeadline{
			Name:        r.Name,
			NameEN:      r.NameEN,
			IsMandatory: r.IsMandatory,
		}
		if r.Code != nil {
			d.Code = *r.Code
		}
		if r.PrimaryParty != nil {
			d.Party = *r.PrimaryParty
		}
		if r.RuleCode != nil {
			d.RuleRef = *r.RuleCode
		}
		if r.DeadlineNotes != nil {
			d.Notes = *r.DeadlineNotes
		}

		// Zero-duration rules either anchor the timeline (trigger date) or
		// represent court-set waypoints with no calculable date.
		if r.DurationValue == 0 {
			if r.ParentID == nil {
				d.IsRootEvent = true
				d.DueDate = triggerDateStr
				d.OriginalDate = triggerDateStr
				if r.Code != nil {
					computed[*r.Code] = triggerDate
				}
			} else {
				d.IsCourtSet = true
				d.DueDate = ""
				d.OriginalDate = ""
			}
			deadlines = append(deadlines, d)
			continue
		}

		// Calculated duration — anchor to parent's adjusted date if we
		// have it, else fall back to the trigger date.
		baseDate := triggerDate
		if r.ParentID != nil {
			// Resolve parent's code from the rules slice so we can look up
			// its already-computed date. Linear scan is fine: rule trees
			// are small (< 20 entries).
			for _, prev := range rules {
				if prev.ID == *r.ParentID {
					if prev.Code != nil {
						if ref, ok := computed[*prev.Code]; ok {
							baseDate = ref
						}
					}
					break
				}
			}
		}

		endDate := addDuration(baseDate, r.DurationValue, r.DurationUnit)
		origDate := endDate
		adjusted, _, wasAdj := s.holidays.AdjustForNonWorkingDays(endDate)

		d.OriginalDate = origDate.Format("2006-01-02")
		d.DueDate = adjusted.Format("2006-01-02")
		d.WasAdjusted = wasAdj
		if r.Code != nil {
			computed[*r.Code] = adjusted
		}
		deadlines = append(deadlines, d)
	}

	return &UIResponse{
		ProceedingType: pt.Code,
		ProceedingName: pt.Name,
		TriggerDate:    triggerDateStr,
		Deadlines:      deadlines,
	}, nil
}

// ListFristenrechnerTypes returns the proceeding types that populate the
// Fristenrechner UI (category = 'fristenrechner'), ordered by sort_order.
func (s *FristenrechnerService) ListFristenrechnerTypes(ctx context.Context) ([]FristenrechnerType, error) {
	rows, err := s.rules.db.QueryxContext(ctx, `
		SELECT code, name, name_en, jurisdiction
		  FROM paliad.proceeding_types
		 WHERE category = 'fristenrechner' AND is_active = true
		 ORDER BY sort_order`)
	if err != nil {
		return nil, fmt.Errorf("list fristenrechner types: %w", err)
	}
	defer rows.Close()

	var out []FristenrechnerType
	for rows.Next() {
		var t FristenrechnerType
		var juris sql.NullString
		if err := rows.Scan(&t.Code, &t.Name, &t.NameEN, &juris); err != nil {
			return nil, err
		}
		if juris.Valid {
			t.Group = juris.String
		}
		out = append(out, t)
	}
	return out, rows.Err()
}

// FristenrechnerType mirrors the /api/tools/proceeding-types response metadata.
type FristenrechnerType struct {
	Code   string `json:"code"`
	Name   string `json:"name"`
	NameEN string `json:"nameEN"`
	Group  string `json:"group"`
}

// addDuration adds a signed duration value/unit to a base date.
func addDuration(base time.Time, value int, unit string) time.Time {
	switch unit {
	case "days":
		return base.AddDate(0, 0, value)
	case "weeks":
		return base.AddDate(0, 0, value*7)
	case "months":
		return base.AddDate(0, value, 0)
	default:
		return base
	}
}