# src/job/report_generate_job.py
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger

from src.iqc.statistic_service import generate_word


async def generate_monthly_report():
    await generate_word()


def setup_scheduler():
    scheduler = AsyncIOScheduler()
    trigger = CronTrigger(day="last", hour=22, minute=0)

    scheduler.add_job(
        generate_monthly_report,
        trigger=trigger,
        id="monthly_report_job",
        name="每月输出质量报告",
        replace_existing=True,
    )

    return scheduler

# src/app.py
@asynccontextmanager
async def lifespan(app: FastAPI):
    scheduler = setup_scheduler()
    scheduler.start()
    app.state.scheduler = scheduler

    yield

    if hasattr(app.state, "scheduler"):
        app.state.scheduler.shutdown()

# src/iqc/statistic_service.py
async def generate_word() -> None:
    base_time = datetime.now()
    month_str = base_time.strftime("%Y年%m月")
    period_end = get_month_end_date(base_time)

    async with async_session_maker() as db:
        result = await db.execute(sa.select(IQCReport))
        reports = result.scalars().all()

        if not reports:
            logger.info("数据库中暂无 IQC 报表数据")
            return

        suppliers = {report.supplier for report in reports if report.supplier}

        for supplier in suppliers:
            supplier_reports = [r for r in reports if r.supplier == supplier]
            file_name = f"{supplier}-{month_str}-质量分析报告.docx"

            supplier_doc = await generate_doc()
            base_info_list = await get_base_info_list(supplier_reports, db, base_time)
            abnormal_list, nonconformity_list = await get_abnormal_info_list(
                supplier_reports, db, base_time
            )
            starred_entry_list = get_starred_spc_charts(supplier_reports, supplier_doc)
            stats = await get_abnormal_stats(
                db, supplier, base_info_list, abnormal_list, nonconformity_list, base_time
            )
            abnormal_entry_list = get_abnormal_summary(supplier_reports, supplier_doc)

            context = {
                "supplier": supplier,
                "datetime": base_time.strftime("%Y年%m月%d日 %H:%M:%S"),
                "period": month_str,
                "baseInfoList": base_info_list,
                "abnormalInfoList": abnormal_list,
                "nonconformityInfoList": nonconformity_list,
                "starredEntries": starred_entry_list,
                "abnormalEntries": abnormal_entry_list,
                **stats,
            }

            if supplier_doc:
                await save_word(file_name, supplier_doc, context)

            await save_monthly_report(db, supplier, period_end, context)

# src/iqc/statistic_service.py
template_path = Path("resource") / "template" / "word_template.docx"
output_dir = Path("resource") / "temp_file"


async def generate_doc() -> DocxTemplate | None:
    if not template_path.exists():
        logger.error(f"错误: 找不到模板文件 {template_path.absolute()}")
        return None

    try:
        doc = DocxTemplate(template_path)
        return doc
    except Exception as e:
        logger.error(f"渲染文档失败: {e}")
        return None


async def save_word(file_name: str, doc: DocxTemplate, context: dict):
    doc.render(context)
    output_path = output_dir / file_name
    output_dir.mkdir(parents=True, exist_ok=True)
    doc.save(output_path)

# src/utils/draw_util.py
def chart_data_to_image(chart_data: Figure | Mapping[str, Any]) -> bytes:
    if chart_data is None:
        raise ValueError("chart_data cannot be None")

    if isinstance(chart_data, Figure):
        fig = chart_data
    else:
        if not chart_data:
            raise ValueError("chart_data cannot be empty")
        fig = Figure(chart_data)

    if not fig.data:
        raise ValueError("chart_data does not contain any trace data")

    return fig.to_image(format="png", width=800, height=500, scale=2)

# src/iqc/statistic_service.py
def get_starred_spc_charts(report_list: list[IQCReport], doc: DocxTemplate) -> list[dict[str, Any]]:
    starred_entry_list = []
    for report in report_list:
        entries = getattr(report, "self_entries", [])
        for entry in entries:
            if entry.starred:
                chart_info = {
                    "code": report.code,
                    "name": entry.name,
                    "cpk_result": entry.cpk_result,
                    "x_bar_r_result": entry.x_bar_r_result,
                }
                if chart_info.get("cpk_result"):
                    cpk_image = chart_data_to_image(chart_info["cpk_result"]["fig_result"]["capability_fig"])
                    chart_info["cpk_image"] = InlineImage(doc, io.BytesIO(cpk_image), width=Mm(180))
                starred_entry_list.append(chart_info)
    return starred_entry_list

# src/iqc/models.py
class IQCMonthlyReport(Base, TimestampTableMixin):
    __tablename__ = "iqc_monthly_report"

    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
    supplier: Mapped[str] = mapped_column(String(100), comment="供应商")
    period: Mapped[date] = mapped_column(Date, comment="报告周期")
    data: Mapped[dict] = mapped_column(JSON, comment="报告数据内容（不含图片）")

# src/iqc/statistic_service.py
async def save_monthly_report(db: AsyncSession, supplier: str, period_end: date, context: dict[str, Any]) -> None:
    image_fields = ["cpk_image", "x_image", "r_image"]
    for entry in context.get("starredEntries", []) + context.get("abnormalEntries", []):
        for field in image_fields:
            entry.pop(field, None)

    stmt = sa.select(IQCMonthlyReport).where(
        sa.and_(
            IQCMonthlyReport.supplier == supplier,
            IQCMonthlyReport.period == period_end,
        )
    )
    result = await db.execute(stmt)
    existing_report = result.scalars().first()

    if existing_report:
        existing_report.data = context
    else:
        report = IQCMonthlyReport(supplier=supplier, period=period_end, data=context)
        db.add(report)

    await db.commit()