#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
mysql_014 ground truth: Notebook执行实例明细按天拆分与引擎关联

Task:
  Filter notebook_span_info for traces with execute.code spans,
  split cross-day records, calculate time metrics, left join engine info,
  write to output table.
"""
import pymysql
import sys

DB_NAME = "internal_platform_db"
INPUT_TABLE_1 = "notebook_span_info_mysql_014"
INPUT_TABLE_2 = "notebook_engine_info_mysql_014"
OUTPUT_TABLE = "dwd_notebook_execute_instance_detail_d_mysql_014"

MYSQL_CONFIG = {
    "host": "localhost",
    "port": 3306,
    "user": "root",
    "password": "root123",
    "charset": "utf8mb4",
}

gt_sql = f"""
INSERT INTO {DB_NAME}.{OUTPUT_TABLE}
    (dt, p_date, trace_id, datawd_project_id, datawd_task_id, datawd_task_instance_id,
     compute_type, status_code, instance_run_time, code_run_time, resource_wait_time,
     code_start_time, code_end_time, instance_start_time, instance_end_time,
     serving_id, is_permanent, apply_for_gpu_count)
WITH
base_data_raw AS (
    SELECT DISTINCT
        trace_id,
        span_name,
        start_time,
        end_time,
        datawd_project_id,
        datawd_task_id,
        datawd_task_instance_id,
        compute_type,
        status_code
    FROM {DB_NAME}.{INPUT_TABLE_1}
    WHERE databus_imp_date >= '2026050400'
      AND databus_imp_date <= '2026050700'
      AND trace_id IN (
        SELECT trace_id
        FROM {DB_NAME}.{INPUT_TABLE_1}
        WHERE databus_imp_date >= '2026050700'
          AND databus_imp_date <= '2026050700'
          AND compute_type = 'ray'
          AND service_name = 'notebook-runner'
          AND span_name = 'runner.execute'
        GROUP BY trace_id
      )
      AND (
          span_name = 'runner.execute'
          OR
          span_name IN ('execute.code', 'execute.code.cell', 'client.execute.code', 'set.permanent.compute', 'create.non.permanent.compute', 'runner.killed')
      )
),
base_data_time_fixed AS (
    SELECT
        trace_id,
        span_name,
        CASE
            WHEN span_name = 'runner.killed'
              THEN MIN(CASE WHEN span_name IN ('execute.code', 'execute.code.cell', 'client.execute.code', 'runner.killed') THEN start_time END)
                      OVER(PARTITION BY trace_id)
            ELSE start_time
        END AS start_time,
        CASE
            WHEN span_name = 'runner.execute'
              THEN MAX(CASE WHEN span_name IN ('runner.execute', 'runner.killed') THEN end_time END)
                      OVER(PARTITION BY trace_id)
            ELSE end_time
        END AS end_time,
        datawd_project_id,
        datawd_task_id,
        datawd_task_instance_id,
        compute_type,
        status_code
    FROM base_data_raw
),
base_data AS (
  SELECT
      trace_id,
      span_name,
      start_time,
      end_time,
      datawd_project_id,
      datawd_task_id,
      datawd_task_instance_id,
      compute_type,
      status_code,
      DATE(FROM_UNIXTIME(CAST(start_time AS SIGNED) / 1000)) as start_date,
      DATE(FROM_UNIXTIME(CAST(end_time AS SIGNED) / 1000)) as end_date,
      DATEDIFF(DATE(FROM_UNIXTIME(CAST(end_time AS SIGNED) / 1000)), DATE(FROM_UNIXTIME(CAST(start_time AS SIGNED) / 1000))) AS diff_days
  FROM base_data_time_fixed
),
pos_series AS (
    SELECT 0 AS pos UNION ALL SELECT 1 AS pos UNION ALL SELECT 2 AS pos UNION ALL SELECT 3 AS pos
),
daily_split_spans AS (
    SELECT
        trace_id,
        span_name,
        datawd_project_id,
        datawd_task_id,
        datawd_task_instance_id,
        compute_type,
        status_code,
        start_date,
        end_date,
        diff_days,
        DATE_ADD(b.start_date, INTERVAL s.pos DAY) AS calc_date,
        CASE WHEN s.pos = 0 THEN CAST(b.start_time AS SIGNED)
             ELSE UNIX_TIMESTAMP(CAST(DATE_ADD(b.start_date, INTERVAL s.pos DAY) AS DATETIME)) * 1000
        END AS start_time,
        CASE WHEN s.pos = b.diff_days THEN CAST(b.end_time AS SIGNED)
             ELSE (UNIX_TIMESTAMP(CAST(DATE_ADD(b.start_date, INTERVAL s.pos + 1 DAY) AS DATETIME)) * 1000) - 1
        END AS end_time,
        CAST(b.start_time AS SIGNED) AS span_start_time,
        CAST(b.end_time AS SIGNED) AS span_end_time
    FROM base_data b
    INNER JOIN pos_series s ON s.pos <= b.diff_days
),
trace_time_metrics AS (
    SELECT
        trace_id,
        calc_date,
        MAX(datawd_project_id) AS datawd_project_id,
        MAX(datawd_task_id) AS datawd_task_id,
        MAX(datawd_task_instance_id) AS datawd_task_instance_id,
        MAX(compute_type) AS compute_type,
        MAX(MAX(CASE WHEN span_name = 'runner.execute' THEN status_code END)) OVER(PARTITION BY trace_id) AS status_code,
        ROUND((MAX(CASE WHEN span_name = 'runner.execute' THEN end_time END) -
               MIN(CASE WHEN span_name = 'runner.execute' THEN start_time END)) / 1000.0) AS instance_run_time,
        ROUND((MAX(CASE WHEN span_name IN ('execute.code', 'client.execute.code', 'execute.code.cell', 'runner.killed') THEN end_time END) -
               MIN(CASE WHEN span_name IN ('execute.code', 'client.execute.code', 'execute.code.cell', 'runner.killed') THEN start_time END)) / 1000.0) AS code_run_time,
        ROUND((MAX(CASE WHEN span_name IN ('set.permanent.compute', 'create.non.permanent.compute') THEN end_time END) -
               MIN(CASE WHEN span_name IN ('set.permanent.compute', 'create.non.permanent.compute') THEN start_time END)) / 1000.0) AS resource_wait_time,
        FROM_UNIXTIME(MIN(CASE WHEN span_name IN ('execute.code', 'client.execute.code', 'execute.code.cell', 'runner.killed') THEN start_time END) / 1000) AS code_start_time,
        FROM_UNIXTIME(MAX(CASE WHEN span_name IN ('execute.code', 'client.execute.code', 'execute.code.cell', 'runner.killed') THEN end_time END) / 1000) AS code_end_time,
        FROM_UNIXTIME(MIN(CASE WHEN span_name = 'runner.execute' THEN span_start_time END) / 1000) AS instance_start_time,
        FROM_UNIXTIME(MAX(CASE WHEN span_name = 'runner.execute' THEN span_end_time END) / 1000) AS instance_end_time
    FROM daily_split_spans
    GROUP BY trace_id, calc_date
)
SELECT
  '20260507' AS dt,
  DATE_FORMAT(t1.calc_date, '%Y-%m-%d') AS p_date,
  t1.trace_id,
  t1.datawd_project_id,
  t1.datawd_task_id,
  t1.datawd_task_instance_id,
  t1.compute_type,
  t1.status_code,
  t1.instance_run_time,
  t1.code_run_time,
  t1.resource_wait_time,
  DATE_FORMAT(t1.code_start_time, '%Y-%m-%d %H:%i:%s') AS code_start_time,
  DATE_FORMAT(t1.code_end_time, '%Y-%m-%d %H:%i:%s') AS code_end_time,
  DATE_FORMAT(t1.instance_start_time, '%Y-%m-%d %H:%i:%s') AS instance_start_time,
  DATE_FORMAT(t1.instance_end_time, '%Y-%m-%d %H:%i:%s') AS instance_end_time,
  t2.serving_id,
  t2.is_permanent,
  t2.apply_for_gpu_count
FROM trace_time_metrics t1
LEFT JOIN (
    SELECT
      trace_id,
      MAX(serving_id) AS serving_id,
      MAX(is_permanent) AS is_permanent,
      SUM(CAST(replicas AS SIGNED) * CAST(num_gpu AS SIGNED)) AS apply_for_gpu_count
    FROM {DB_NAME}.{INPUT_TABLE_2}
    WHERE databus_imp_date >= '2026050400'
      AND databus_imp_date <= '2026050700'
      AND compute_type = 'ray'
      AND service_name = 'notebook-runner'
    GROUP BY trace_id
  ) t2 ON t1.trace_id = t2.trace_id
"""


def main():
    conn = pymysql.connect(**MYSQL_CONFIG)

    try:
        with conn.cursor() as cur:
            # Set timezone to Asia/Shanghai so FROM_UNIXTIME aligns with expected dates
            cur.execute("SET time_zone = '+08:00'")

            # Ensure output table exists
            cur.execute(f"""
                CREATE TABLE IF NOT EXISTS {DB_NAME}.{OUTPUT_TABLE} (
                    `dt` VARCHAR(256) COMMENT '天分区',
                    `p_date` VARCHAR(256) COMMENT '拆分后日期',
                    `trace_id` VARCHAR(256) COMMENT 'trace_id',
                    `datawd_project_id` VARCHAR(256) COMMENT '项目ID',
                    `datawd_task_id` VARCHAR(256) COMMENT '任务ID',
                    `datawd_task_instance_id` VARCHAR(256) COMMENT '任务实例ID',
                    `compute_type` VARCHAR(256) COMMENT '计算类型',
                    `status_code` INT COMMENT '状态码',
                    `instance_run_time` INT COMMENT '实例运行时长(秒)',
                    `code_run_time` INT COMMENT '代码执行时长(秒)',
                    `resource_wait_time` INT COMMENT '资源等待时长(秒)',
                    `code_start_time` VARCHAR(256) COMMENT '代码开始时间',
                    `code_end_time` VARCHAR(256) COMMENT '代码结束时间',
                    `instance_start_time` VARCHAR(256) COMMENT '实例开始时间',
                    `instance_end_time` VARCHAR(256) COMMENT '实例结束时间',
                    `serving_id` VARCHAR(256) COMMENT 'serving_id',
                    `is_permanent` VARCHAR(256) COMMENT '是否永久引擎',
                    `apply_for_gpu_count` INT COMMENT 'GPU申请数量'
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
            """)

            # Truncate + insert
            cur.execute(f"TRUNCATE TABLE {DB_NAME}.{OUTPUT_TABLE}")
            cur.execute(gt_sql)

        conn.commit()

        # Verify row count
        with conn.cursor() as cur:
            cur.execute(f"SELECT COUNT(*) FROM {DB_NAME}.{OUTPUT_TABLE}")
            count = cur.fetchone()[0]

        print(f"mysql_014 ground_truth done: {count} rows written to output table")
    except Exception as e:
        print(f"ground_truth error: {e}", file=sys.stderr)
        conn.rollback()
        sys.exit(1)
    finally:
        conn.close()


if __name__ == "__main__":
    main()