"""
文章管理服务模块
=============================================================

该模块实现了文章管理相关的所有业务逻辑。
包括文章的分页查询、详情查询、添加、更新、删除、状态设置、点击率统计等功能。

命名规范：
- 函数参数使用驼峰命名（如 articleId, pageNo）
- 表单字段使用下划线命名（如 title, category_id）- 与数据库字段保持一致
- 返回数据使用驼峰命名（如 createUser, updateTime）- 与前端规范保持一致
- 私有函数以下划线开头（如 _apply_filters, _build_page_data）

功能模块：
1. 分页查询：支持按标题模糊搜索、分类筛选、状态筛选，按sort字段排序
2. 详情查询：根据ID获取单个文章的详细信息
3. 数据维护：文章的添加、更新、删除（支持批量）
4. 状态管理：单独更新文章的启用/下架状态
5. 点击统计：增加文章点击量
6. 文章列表：获取所有文章列表（用于下拉选择等场景）
"""

import logging
from datetime import datetime, timezone

from flask import request
from sqlalchemy import and_

from application.constants.common import PAGE_SIZE
from application.constants.dict import ARTICLE_STATUS_LIST
from application.forms.article import ArticleForm, ArticleStatusForm
from application.models.article import Article
from config import FLASK_FILE_URL
from extensions import db
from utils import R, regular
from utils.case_converter import convert_camel_to_snake
from utils.model_utils import models_to_list, model_to_dict
from utils.request import parse_request_body, parse_id_list, like_contains
from utils.rich_text import get_file_url, save_file, save_content
from utils.security import get_username

# 获取日志记录器
logger = logging.getLogger(__name__)


# ============================================================
# 文章分页查询
# ============================================================

def get_article_page():
    """
    查询文章分页数据

    Args:
        request: Flask request对象，包含查询参数
            - pageNo: 当前页码（可选，默认为1）
            - pageSize: 每页记录数（可选，默认为PAGE_SIZE）
            - title: 文章标题（可选，模糊查询）
            - category_id: 分类ID（可选，精确查询）
            - status: 文章状态（可选，精确查询）
            - startTime: 开始时间（可选）
            - endTime: 结束时间（可选）

    Returns:
        R: 包含分页数据的JSON响应，格式为：
            {
                "records": 文章列表,
                "total": 总记录数,
                "size": 每页大小,
                "current": 当前页码,
                "pages": 总页数
            }
    """
    try:
        # 获取分页参数
        page_no = int(request.args.get('pageNo', 1))
        page_size = int(request.args.get('pageSize', PAGE_SIZE))

        # 应用筛选条件
        query = _apply_filters()

        # 记录总数
        total = query.count()
        # 计算总页数
        pages = (total + page_size - 1) // page_size if total > 0 else 0

        # 分页查询
        article_list = query.order_by(Article.sort.asc(), Article.create_time.desc()) \
            .limit(page_size) \
            .offset((page_no - 1) * page_size) \
            .all()

        # 构建返回数据
        page_data = _build_page_data(article_list, total, page_size, page_no, pages)
        return R.ok(data=page_data)

    except Exception as e:
        logger.error(f"查询文章分页数据异常: {str(e)}")
        return R.failed(msg="查询失败，请稍后重试")


def _apply_filters():
    """
    应用查询筛选条件

    根据请求参数动态构建查询条件：
        - 自动过滤已删除记录（is_delete == 0）
        - 支持文章标题模糊查询
        - 支持分类ID精确查询
        - 支持文章状态精确查询
        - 支持时间范围查询

    Returns:
        Query: 应用筛选后的SQLAlchemy查询对象
    """
    # 基础查询：过滤已删除记录
    query = Article.query.filter(Article.is_delete == 0)

    # 文章标题模糊筛选
    title = request.args.get('title')
    if title:
        query = query.filter(Article.title.like(like_contains(title), escape='\\'))

    # 分类ID精确筛选
    category_id = request.args.get('categoryId')
    if category_id:
        query = query.filter(Article.category_id == category_id)

    # 文章状态精确筛选
    status = request.args.get('status')
    if status:
        query = query.filter(Article.status == status)

    # 时间范围筛选
    start_time = request.args.get('startTime')
    end_time = request.args.get('endTime')

    if start_time:
        try:
            start_date = datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S')
            query = query.filter(Article.create_time >= start_date)
        except ValueError:
            pass

    if end_time:
        try:
            end_date = datetime.strptime(end_time, '%Y-%m-%d %H:%M:%S')
            query = query.filter(Article.create_time <= end_date)
        except ValueError:
            pass

    return query


def _build_page_data(article_list, total, page_size, page_no, pages):
    """
    构建分页返回数据

    Args:
        article_list: 文章对象列表
        total: 总记录数
        page_size: 每页大小
        page_no: 当前页码
        pages: 总页数

    Returns:
        dict: 分页数据，包含 records、total、size、current、pages
    """
    # 将模型对象列表转换为字典列表
    records = models_to_list(article_list)

    # 为每条记录添加状态文本映射
    for record in records:
        # 文章封面
        record['cover'] = get_file_url(record.get('cover'))
        # 文章状态
        record['statusText'] = ARTICLE_STATUS_LIST.get(record.get('status'))

    return {
        'records': records,
        'total': total,
        'size': page_size,
        'current': page_no,
        'pages': pages
    }


# ============================================================
# 文章详情查询
# ============================================================

def get_article_detail(article_id):
    """
    根据ID查询文章详情（返回字典格式）

    此方法调用 get_info 获取模型对象，然后转换为字典格式返回。
    适用于前端接口调用。

    Args:
        article_id: 文章ID

    Returns:
        dict/None: 文章详情字典，不存在时返回 None
    """
    try:
        # 复用 get_info 方法查询文章
        article = get_info(article_id)
        if not article:
            return None
        # 转换为字典格式
        record = model_to_dict(article)

        # 图片封面
        record['cover'] = get_file_url(record['cover'])

        # 处理图集（逗号分隔转URL列表）
        images = record.get('images')
        if images:
            # 将逗号分隔的路径转换为URL列表
            image_paths = [path.strip() for path in images.split(',') if path.strip()]
            record['imagesList'] = [get_file_url(path) for path in image_paths]
        else:
            record['imagesList'] = []

        # 富文本处理
        content = record.get('content')
        if content:
            record['content'] = content.replace("[IMG_URL]", FLASK_FILE_URL)

        # 文章状态
        record['statusText'] = ARTICLE_STATUS_LIST.get(record.get('status'))

        return record

    except Exception as e:
        logger.error(f"查询文章详情异常，ID: {article_id}, 错误: {str(e)}")
        return None


# ============================================================
# 文章信息查询（根据ID）- 核心查询方法
# ============================================================

def get_info(article_id: int):
    """
    根据ID查询文章信息（返回模型对象）

    这是一个通用的文章查询方法，返回文章模型对象而非字典。
    与 get_article_detail 的区别：
        - get_article_detail: 返回字典格式，用于前端接口
        - get_info: 返回模型对象，用于内部服务调用

    此方法被以下方法复用：
        - get_article_detail: 获取详情字典
        - update_article: 验证文章是否存在
        - update_article_status: 验证文章是否存在
        - increment_click: 增加点击量

    Args:
        article_id: 文章ID

    Returns:
        Article/None: 文章模型对象，不存在或已删除时返回 None

    Example:
        article = get_info(article_id)
        if article:
            print(article.title)
    """
    # 参数有效性验证
    if not article_id or article_id <= 0:
        return None

    try:
        # 查询未删除的文章
        article = Article.query.filter(
            and_(Article.id == article_id, Article.is_delete == 0)
        ).first()
        return article
    except Exception as e:
        logger.error(f"查询文章信息异常，ID: {article_id}, 错误: {str(e)}")
        return None


# ============================================================
# 文章添加
# ============================================================

def add_article():
    """
    添加文章

    流程：
        1. 解析请求体JSON数据
        2. 表单验证
        3. 处理images字段（JSON序列化）
        4. 创建文章对象并保存到数据库

    Returns:
        R: 操作结果
    """
    try:
        # 获取参数
        json_data, error = parse_request_body()
        if error:
            return R.failed(msg=error)

        # 表单验证
        form = ArticleForm(data=json_data)
        if not form.validate():
            err_msg = regular.get_err(form)
            return R.failed(msg=err_msg)

        # 文章封面
        cover = form.data.get('cover')
        if cover:
            cover = save_file(cover, "article")
            form.cover.data = cover

        # 文章图集（逗号分隔的图片路径）
        images = form.data.get('images')
        if images:
            image_paths = [img.strip() for img in images.split(',') if img.strip()]
            processed_paths = []
            for img in image_paths:
                image = save_file(img, "article")
                processed_paths.append(image)
            # 处理后的地址逗号分隔
            form.images.data = ','.join(processed_paths)

        # 文章内容
        title = form.data.get('title', '')
        content = form.data.get('content', '')
        if content:
            form.content.data = save_content(content, title, "article")

        # 创建文章
        article = Article(**form.data)
        article.create_user = get_username()
        article.save()

        return R.ok(msg="添加成功")

    except Exception as e:
        logger.error(f"添加文章异常: {str(e)}")
        return R.failed(msg="添加文章失败，请稍后重试")


# ============================================================
# 文章更新
# ============================================================

def update_article():
    """
    更新文章

    流程：
        1. 解析请求体JSON数据
        2. 表单验证
        3. 验证文章是否存在（复用 get_info）
        4. 处理images字段
        5. 更新文章信息

    Returns:
        R: 操作结果
    """
    try:
        # 获取参数
        json_data, error = parse_request_body()
        if error:
            return R.failed(msg=error)

        # 表单验证
        form = ArticleForm(data=json_data)
        if not form.validate():
            return R.failed(msg=regular.get_err(form))

        # 获取文章ID
        article_id = form.data.get('id')
        if not article_id or int(article_id) <= 0:
            return R.failed("文章ID无效")
        article_id = int(article_id)

        # 复用 get_info 方法验证文章是否存在
        article = get_info(article_id)
        if not article:
            return R.failed("文章不存在")

        # 文章封面
        cover = form.data.get('cover')
        if cover:
            cover = save_file(cover, "article")
            form.cover.data = cover

        # 文章图集（逗号分隔的图片路径）
        images = form.data.get('images')
        if images:
            image_paths = [img.strip() for img in images.split(',') if img.strip()]
            processed_paths = []
            for img in image_paths:
                image = save_file(img, "article")
                processed_paths.append(image)
            # 处理后的地址逗号分隔
            form.images.data = ','.join(processed_paths)

        # 文章内容
        title = form.data.get('title', '')
        content = form.data.get('content', '')
        if content:
            form.content.data = save_content(content, title, "article")

        # 更新文章信息（移除ID，避免更新主键）
        form_data = convert_camel_to_snake(form.data.copy())
        form_data.pop('id', None)

        form_data['update_time'] = datetime.now(tz=timezone.utc)
        form_data['update_user'] = get_username()

        result = Article.query.filter_by(id=article_id).update(form_data)

        if not result:
            return R.failed("更新失败")

        return R.ok(msg="更新成功")

    except Exception as e:
        logger.error(f"更新文章异常: {str(e)}")
        return R.failed(msg="更新文章失败，请稍后重试")


# ============================================================
# 文章删除
# ============================================================

def delete_articles(article_ids):
    """
    删除文章（批量删除）

    删除
    支持逗号分隔的多个ID批量删除。

    Args:
        article_ids: 文章ID字符串，多个ID用逗号分隔，如 "1,2,3"

    Returns:
        R: 操作结果
    """
    return Article.batch_delete_r(article_ids)


# ============================================================
# 文章状态设置
# ============================================================

def update_article_status():
    """
    设置文章状态

    单独更新文章的启用/下架状态，不涉及其他字段。

    Returns:
        R: 操作结果
    """
    try:
        # 获取参数
        json_data, error = parse_request_body()
        if error:
            return R.failed(msg=error)

        # 表单验证
        form = ArticleStatusForm(data=json_data)
        if not form.validate():
            err_msg = regular.get_err(form)
            return R.failed(msg=err_msg)

        article_id = int(form.data['id'])
        status = int(form.data['status'])

        # 复用 get_info 方法验证文章是否存在
        article = get_info(article_id)
        if not article:
            return R.failed("文章不存在")

        # 更新状态
        update_data = {"status": status, "update_time": datetime.now(tz=timezone.utc), "update_user": get_username()}
        result = Article.query.filter_by(id=article_id).update(update_data)

        if not result:
            return R.failed("设置失败")

        return R.ok(msg="设置成功")

    except Exception as e:
        logger.error(f"设置文章状态异常: {str(e)}")
        return R.failed(msg="设置文章状态失败，请稍后重试")