# app/utils/search.py
import re

def highlight_excerpt(text: str, query: str, max_length: int = 300) -> str:
    """
Extract snippets from text that contain search terms and highlight them
:param text: original text (plain text is passed here, Markdown/HTML tags have been removed)
:param query: search keywords
:param max_length: Maximum truncation length when no match
:return: HTML fragment with <mark> highlighting
    """
    if not text or not query:
        return text[:max_length] if text else ""

#Search case-insensitively
    pattern = re.compile(re.escape(query), re.IGNORECASE)
    match = pattern.search(text)

    if match:
# Keep the context of max_length//2 before and after the keyword
        context_length = max_length // 2
        start = max(0, match.start() - context_length)
        end = min(len(text), match.end() + context_length)
        excerpt = text[start:end]

# Fragment truncation tips
        if start > 0:
            excerpt = "..." + excerpt
        if end < len(text):
            excerpt += "..."
    else:
        excerpt = text[:max_length]
        if len(text) > max_length:
            excerpt += "..."

# Highlight: Keep the original case and wrap it with <mark> tag
    highlighted = pattern.sub(lambda m: f'<mark class="search-highlight">{m.group()}</mark>', excerpt)
    return highlighted

# app/articles/routes.py (replace the original search function, pay attention to introducing necessary models and modules)
from datetime import datetime, timedelta
from app.articles.models import Category # Assume there is already a Category model

@articles_bp.route("/search")
def search():
    query = request.args.get("q", "").strip()
    category_id = request.args.get("category", type=int)
    date_from = request.args.get("from", type=str)
    recent_days = request.args.get("recent", type=int)
    page = request.args.get("page", 1, type=int)

# Get the categories of all published articles (for drop-down box)
    categories = Category.query.join(Category.posts).filter(Post.is_published.is_(True)).distinct().all()

    base_query = Post.query.filter(Post.is_published.is_(True))

# Keyword filter
    if query:
        search_pattern = f"%{query}%"
        base_query = base_query.filter(
            or_(
                Post.title.ilike(search_pattern),
                Post.summary.ilike(search_pattern),
                Post.content.ilike(search_pattern),
            )
        )

# Classification filtering
    if category_id:
        base_query = base_query.filter_by(category_id=category_id)

# Time filtering: use the specified date first, followed by "near N days"
    if date_from:
        try:
            start_date = datetime.fromisoformat(date_from)
            base_query = base_query.filter(Post.created_at >= start_date)
        except ValueError:
pass # Invalid dates are ignored directly
    elif recent_days:
        start_date = datetime.utcnow() - timedelta(days=recent_days)
        base_query = base_query.filter(Post.created_at >= start_date)

    pagination = (
        base_query
        .order_by(Post.created_at.desc())
        .paginate(page=page, per_page=20, error_out=False)
    )

    return render_template(
        "articles/search.html",
        results=pagination.items,
        query=query,
        categories=categories,
        selected_category=category_id,
        selected_from=date_from,
        selected_recent=recent_days,
        pagination=pagination,
        total=pagination.total,
    )

# Replace the keyword filtering part in the search route
from sqlalchemy import func

@articles_bp.route("/search")
def search():
#...The previous parameter acquisition, time/category filtering, and paging logic remain unchanged...

    if query:
#Build a search vector: combine the title and text into a Chinese search vector (|| is the vector merging symbol)
        search_vector = (
            func.to_tsvector("chinese", Post.title)
            .op("||")(func.to_tsvector("chinese", Post.content))
        )
# Build query: plainto_tsquery will automatically convert the spaces entered by the user into "and" logic
        ts_query = func.plainto_tsquery("chinese", query)
# Filter and order descending by relevance
        base_query = (
            base_query
.filter(search_vector.op("@@")(ts_query)) # @@ is the full-text matching operator
            .order_by(func.ts_rank(search_vector, ts_query).desc())
        )

# ... paging and rendering ...

# app/articles/models.py
from app import db

class Post(db.Model):
# ...original fields ...
#Add search vector column (PostgreSQL 12+ supports calculated columns)
    search_vector = db.Column(
        db.TSVECTOR,
        db.Computed(
            "to_tsvector('chinese', coalesce(title, '') || ' ' || coalesce(content, ''))",
            persisted=True,
        ),
    )
#Create GIN index
    __table_args__ = (db.Index("idx_post_search_vector", search_vector, postgresql_using="gin"),)

# Modify the definition of computed column
db.Computed(
    "setweight(to_tsvector('chinese', coalesce(title, '')), 'A') || "
    "setweight(to_tsvector('chinese', coalesce(summary, '')), 'B') || "
    "setweight(to_tsvector('chinese', coalesce(content, '')), 'D')",
    persisted=True,
)