#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
测试部位温度记录表生成脚本

- 忽略传入的 experimentProcess，自行构造固定结构的数据
- 从 InfluxDB 查询每个测试部位在各时间点的瞬时温度值
- 输出格式与应用中的 scriptTable 占位符兼容
- 默认把 {scriptTable1} 放在“测试部位”所在的单元格

环境变量：
    TABLE_TOKEN         目标占位符，默认 scriptTable1
    TABLE_START_ROW     写入起始行偏移，默认 0
    TABLE_START_COL     写入起始列偏移，默认 0
    TABLE_TIME_SLOTS    逗号分隔的时间刻度，默认 "0.5h,1h,1.5h,2h,2.5h,3h,3.5h"
    TABLE_MOTOR_SPEED   电机转速标签，默认 "980RPM"
    EXPERIMENT_START     实验开始时间（ISO 8601 格式，如 2024-01-01T10:00:00Z）
    EXPERIMENT_END       实验结束时间（ISO 8601 格式）
    INFLUX_URL           InfluxDB URL
    INFLUX_ORG           InfluxDB 组织
    INFLUX_TOKEN         InfluxDB 访问令牌
    INFLUX_BUCKET        InfluxDB bucket 名称
    INFLUX_MEASUREMENT   InfluxDB measurement 名称
"""

from __future__ import annotations

import json
import logging
import os
import sys
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional


LOGGER = logging.getLogger(__name__)


def _mask_secret(value: Optional[str]) -> str:
    if value is None:
        return "<unset>"
    value = value.strip()
    if not value:
        return "<empty>"
    if len(value) <= 4:
        return "****"
    return f"{value[:4]}****"


def _log_environment_variables() -> None:
    env_keys = [
        "TABLE_TOKEN",
        "TABLE_START_ROW",
        "TABLE_START_COL",
        "TABLE_TIME_SLOTS",
        "TABLE_MOTOR_SPEED",
        "TABLE_LOG_LEVEL",
        "TABLE_LOG_FILE",
        "EXPERIMENT_START",
        "EXPERIMENT_END",
        "INFLUX_URL",
        "INFLUX_ORG",
        "INFLUX_TOKEN",
        "INFLUX_BUCKET",
        "INFLUX_MEASUREMENT",
    ]

    for key in env_keys:
        raw_value = os.environ.get(key)
        if key.endswith("TOKEN") or key.endswith("PASSWORD"):
            display_value = _mask_secret(raw_value)
        else:
            display_value = raw_value if raw_value is not None else "<unset>"
        LOGGER.info("ENV %s = %s", key, display_value)


def _read_all_stdin() -> str:
    try:
        if sys.stdin and not sys.stdin.closed and not sys.stdin.isatty():
            return sys.stdin.read()
    except Exception:
        pass
    return ""


def _load_payload() -> Dict[str, Any]:
    raw = _read_all_stdin().strip()

    if not raw and len(sys.argv) > 1:
        arg = sys.argv[1]
        if os.path.exists(arg) and os.path.isfile(arg):
            with open(arg, "r", encoding="utf-8") as fh:
                raw = fh.read()
        else:
            raw = arg

    if not raw:
        raw = os.environ.get("EXPERIMENT_JSON", "").strip()

    if not raw:
        raw = "{}"

    data = json.loads(raw)
    if not isinstance(data, dict):
        raise ValueError("experiment JSON must be a dict")
    return data


def _time_slots() -> List[str]:
    raw = os.environ.get("TABLE_TIME_SLOTS", "").strip()
    if not raw:
        # 根据图片，时间刻度是：0.5h, 1h, 1.5h, 2h, 2.5h, 3h, 3.5h（7列）
        return ["0.5h", "1h", "1.5h", "2h", "2.5h", "3h", "3.5h"]
    slots = [slot.strip() for slot in raw.split(",")]
    return [slot for slot in slots if slot]


def _default_sections() -> List[Dict[str, Any]]:
    # name -> rows underneath（entries）
    # 每个 entry 对应一个测试部位，需要映射到 InfluxDB 的 field 或 tag
    return [
        {"name": "主轴承", "entries": [
            {"label": "#1", "field": "主轴承#1", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#1"},
            {"label": "#2", "field": "主轴承#2", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#2"},
            {"label": "#3", "field": "主轴承#3", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#3"},
            {"label": "#4", "field": "主轴承#4", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#4"},
            {"label": "#5", "field": "主轴承#5", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#5"},
            {"label": "#6", "field": "主轴承#6", "filters": {"data_type": "LSDAQ"}, "result_key": "主轴承#6"},
        ]},
        {"name": "十字头", "entries": [
            {"label": "#1", "field": "十字头#1", "filters": {"data_type": "LSDAQ"}, "result_key": "十字头#1"},
            {"label": "#2", "field": "十字头#2", "filters": {"data_type": "LSDAQ"}, "result_key": "十字头#2"},
            {"label": "#3", "field": "十字头#3", "filters": {"data_type": "LSDAQ"}, "result_key": "十字头#3"},
            {"label": "#4", "field": "十字头#4", "filters": {"data_type": "LSDAQ"}, "result_key": "十字头#4"},
            {"label": "#5", "field": "十字头#5", "filters": {"data_type": "LSDAQ"}, "result_key": "十字头#5"},
        ]},
        {"name": "减速箱小轴承", "entries": [
            {"label": "#1（输入法兰端）", "field": "减速箱小轴承1", "filters": {"data_type": "LSDAQ"}, "result_key": "减速箱小轴承#1"},
            {"label": "#2", "field": "减速箱小轴承#2", "filters": {"data_type": "LSDAQ"}, "result_key": "减速箱小轴承#2"},
        ]},
        {"name": "减速箱大轴承", "entries": [
            {"label": "#3（大端盖端）", "field": "减速箱大轴承#3", "filters": {"data_type": "LSDAQ"}, "result_key": "减速箱大轴承#3"},
            {"label": "#4", "field": "减速箱大轴承#4", "filters": {"data_type": "LSDAQ"}, "result_key": "减速箱大轴承#4"},
        ]},
        {"name": "润滑油温", "entries": [
            {"label": "", "field": "mean", "filters": {"data_type": "润滑油温"}, "result_key": "润滑油温"},
        ]},
        {"name": "润滑油压", "entries": [
            {"label": "(Psi)", "field": "mean", "filters": {"data_type": "润滑油压"}, "result_key": "润滑油压"},
        ]},
    ]


def _parse_time_slot(slot_str: str) -> float:
    """解析时间刻度字符串（如 '0.5h', '1h'）为小时数"""
    slot_str = slot_str.strip().lower()
    if slot_str.endswith('h'):
        try:
            return float(slot_str[:-1])
        except ValueError:
            pass
    return 0.0


def _query_influxdb(
    field_name: str,
    start_time: datetime,
    end_time: datetime,
    influx_url: str,
    influx_org: str,
    influx_token: str,
    influx_bucket: str,
    influx_measurement: str,
    filters: Optional[Dict[str, str]] = None,
) -> Optional[float]:
    """查询 InfluxDB 获取指定字段在指定时间点的瞬时值"""
    try:
        from influxdb_client import InfluxDBClient
        import pandas as pd
        import warnings
        from influxdb_client.client.warnings import MissingPivotFunction
    except ImportError:
        LOGGER.warning("InfluxDB client not available, skip query for field=%s", field_name)
        return None

    try:
        client = InfluxDBClient(url=influx_url, org=influx_org, token=influx_token)
        query_api = client.query_api()

        # 构建 Flux 查询
        start_rfc3339 = start_time.strftime('%Y-%m-%dT%H:%M:%SZ')
        stop_rfc3339 = end_time.strftime('%Y-%m-%dT%H:%M:%SZ')

        tag_filters = ""
        if filters:
            for key, value in filters.items():
                tag_filters += f'\n  |> filter(fn: (r) => r["{key}"] == "{value}")'

        LOGGER.debug(
            "Querying field=%s measurement=%s target_time=%s filters=%s",
            field_name,
            influx_measurement,
            end_time.strftime('%Y-%m-%dT%H:%M:%SZ'),  # 使用end_time作为目标时间点
            filters or {},
        )

        # 修改查询逻辑：查询目标时间点附近的最近一个数据点
        # 使用一个小的时间窗口（比如前后5分钟）来查找最接近的数据点
        target_time = end_time
        window_minutes = 5  # 前后5分钟的窗口
        
        query_start = target_time - timedelta(minutes=window_minutes)
        query_end = target_time + timedelta(minutes=window_minutes)
        
        query_start_rfc = query_start.strftime('%Y-%m-%dT%H:%M:%SZ')
        query_end_rfc = query_end.strftime('%Y-%m-%dT%H:%M:%SZ')

        flux = f'''
from(bucket: "{influx_bucket}")
  |> range(start: {query_start_rfc}, stop: {query_end_rfc})
  |> filter(fn: (r) => r["_measurement"] == "{influx_measurement}")
  |> filter(fn: (r) => r["_field"] == "{field_name}")
  |> filter(fn: (r) => true){tag_filters}
  |> sort(columns: ["_time"])
  |> last()
  |> yield(name: "instantaneous")
'''.strip()

        with warnings.catch_warnings():
            warnings.simplefilter("ignore", MissingPivotFunction)
            frames = query_api.query_data_frame(flux)
        
        if isinstance(frames, list):
            df = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
        else:
            df = frames

        # 获取瞬时值（最近的一个数据点）
        if df.empty or '_value' not in df.columns:
            LOGGER.debug("No instantaneous value found for field=%s", field_name)
            return None
            
        # 取第一行的值（因为查询已经排序并取了last()）
        instant_value = df['_value'].iloc[0]
        if pd.isna(instant_value):
            LOGGER.debug("Instantaneous value is NaN for field=%s", field_name)
            return None

        value = float(instant_value)
        
        # 如果有时间信息，记录实际的数据时间点
        if '_time' in df.columns:
            actual_time = df['_time'].iloc[0]
            LOGGER.debug("Field=%s instantaneous_value=%.3f actual_time=%s", field_name, value, actual_time)
        else:
            LOGGER.debug("Field=%s instantaneous_value=%.3f", field_name, value)
            
        return value
    except Exception as e:
        LOGGER.error("Error querying InfluxDB for field=%s: %s", field_name, e)
        return None
    finally:
        try:
            client.close()
        except Exception:
            pass


def _get_default_temperature(field_name: str, filters: Optional[Dict[str, Any]] = None) -> float:
    """为每个测试部位返回默认温度值（用于测试或演示）"""
    data_type = ""
    if filters:
        data_type = str(filters.get("data_type", ""))

    defaults: Dict[tuple, float] = {
        ("主轴承#1", ""): 25.5,
        ("主轴承#2", ""): 26.0,
        ("主轴承#3", ""): 25.8,
        ("主轴承#4", ""): 26.2,
        ("主轴承#5", ""): 25.9,
        ("主轴承#6", ""): 26.1,
        ("十字头#1", ""): 28.0,
        ("十字头#2", ""): 28.2,
        ("十字头#3", ""): 27.8,
        ("十字头#4", ""): 28.1,
        ("十字头#5", ""): 27.9,
        ("减速箱小轴承#1", ""): 30.0,
        ("减速箱小轴承#2", ""): 30.2,
        ("减速箱大轴承#3", ""): 29.5,
        ("减速箱大轴承#4", ""): 29.8,
        ("mean", "润滑油温"): 35.0,
        ("mean", "润滑油压"): 50.0,
    }

    return defaults.get((field_name, data_type), 25.0)  # 默认25.0度


def _build_cells(
    time_slots: List[str],
    sections: List[Dict[str, Any]],
    motor_speed: str,
    start_time: Optional[datetime] = None,
    end_time: Optional[datetime] = None,
    temperature_data: Optional[Dict[str, Dict[str, float]]] = None,
    use_defaults: bool = False,
) -> List[Dict[str, Any]]:
    cells: List[Dict[str, Any]] = []

    def add_cell(row: int, col: int, value: str = "", rowspan: int = 1, colspan: int = 1) -> None:
        payload: Dict[str, Any] = {"row": row, "col": col, "value": value}
        if rowspan > 1:
            payload["rowspan"] = rowspan
        if colspan > 1:
            payload["colspan"] = colspan
        cells.append(payload)

    # 模板左侧标题列已经去除，这里仅生成纯数据区，从 (0,0) 开始填入数值。
    # current_row 对应模板中的实际数据行索引。
    current_row = 0
    for section in sections:
        entries = section.get("entries") or []
        if not entries:
            continue
        # 每个测试部位子项对应模板中的一行
        for entry in entries:
            # 支持新格式（带 field 映射）和旧格式（纯字符串）
            if isinstance(entry, dict):
                field_name = entry.get("field", "")
                entry_filters = entry.get("filters")
                entry_key = entry.get("result_key") or field_name
            else:
                field_name = ""
                entry_filters = None
                entry_key = ""

            # 仅输出数值列：列索引直接对应时间段
            # 强制填充所有列，优先使用查询数据，否则使用默认值
            if field_name:
                # 根据配置决定是否启用默认值
                default_base_value: Optional[float] = None
                if use_defaults:
                    default_base_value = _get_default_temperature(field_name, entry_filters)
                target_key = entry_key or field_name

                # 遍历所有时间段列，确保每一列都有数据
                for col_idx, slot in enumerate(time_slots):
                    value = None

                    # 优先使用查询到的数据
                    if temperature_data:
                        slot_data = temperature_data.get(target_key, {})
                        if slot_data:
                            slot_key = f"{col_idx}_{slot}"
                            value = slot_data.get(slot_key)

                    if value is None and use_defaults and default_base_value is not None:
                        # 使用基础默认值 + 时间段偏移（每个时间段增加0.1度）
                        time_offset = col_idx * 0.1
                        value = default_base_value + time_offset

                    if value is None:
                        value_str = ""
                    else:
                        # 格式化为字符串（保留1位小数）
                        value_str = f"{value:.1f}"

                    add_cell(current_row, col_idx, value_str)
            else:
                # 如果没有字段名，填充空字符串
                for col_idx in range(len(time_slots)):
                    add_cell(current_row, col_idx, "")
            current_row += 1

    return cells


def _load_temperature_data(
    time_slots: List[str],
    sections: List[Dict[str, Any]],
    start_time: Optional[datetime],
    end_time: Optional[datetime],
) -> Dict[str, Dict[str, float]]:
    """从 InfluxDB 查询所有测试部位在各时间点的瞬时温度值"""
    if not start_time or not end_time:
        LOGGER.info("Skip data query: missing start/end (%s, %s)", start_time, end_time)
        return {}
    
    influx_url = os.environ.get("INFLUX_URL", "").strip()
    influx_org = os.environ.get("INFLUX_ORG", "").strip()
    influx_token = os.environ.get("INFLUX_TOKEN", "").strip()
    influx_bucket = os.environ.get("INFLUX_BUCKET", "PCM").strip()
    influx_measurement = os.environ.get("INFLUX_MEASUREMENT", "PCM_Measurement").strip()
    
    if not all([influx_url, influx_org, influx_token, influx_bucket, influx_measurement]):
        LOGGER.warning(
            "Skip data query: missing Influx config url=%s bucket=%s measurement=%s",
            influx_url or "<empty>",
            influx_bucket or "<empty>",
            influx_measurement or "<empty>",
        )
        return {}
    
    # 计算总时长（小时）
    total_duration = (end_time - start_time).total_seconds() / 3600.0
    LOGGER.info(
        "Fetch instantaneous temperature data window=%s→%s total_hours=%.3f time_points=%s",
        start_time.isoformat(),
        end_time.isoformat(),
        total_duration,
        ",".join(time_slots),
    )
    
    # 收集所有需要查询的字段
    query_targets: List[Tuple[str, Dict[str, Any]]] = []
    for section in sections:
        entries = section.get("entries") or []
        for entry in entries:
            if isinstance(entry, dict):
                field_name = entry.get("field", "")
                if field_name:
                    query_targets.append((field_name, entry))

    if not query_targets:
        return {}
    
    # 为每个时间点查询瞬时数据
    # 时间刻度采用累计写法（0.5h、1h、1.5h…），每个时间点查询对应时刻的瞬时值
    temperature_data: Dict[str, Dict[str, float]] = {}
    
    # 计算每个时间点的偏移（小时）
    # 0.5h表示实验开始后0.5小时的时间点，1h表示实验开始后1小时的时间点，以此类推
    slot_durations = [_parse_time_slot(slot) for slot in time_slots]
    positive_slot_durations = [hours for hours in slot_durations if hours > 0]
    max_slot_hours = max(positive_slot_durations) if positive_slot_durations else 0.0
    force_start_based_window = bool(positive_slot_durations) and (total_duration + 1e-9 < max_slot_hours)
    if force_start_based_window:
        LOGGER.debug(
            "Total duration %.3fh shorter than max slot %.3fh, fall back to start-based windows",
            total_duration,
            max_slot_hours,
        )

    prev_slot_end = 0.0
    for idx, slot_str in enumerate(time_slots):
        slot_hours = slot_durations[idx] if idx < len(slot_durations) else _parse_time_slot(slot_str)
        if slot_hours <= 0:
            LOGGER.debug("Skip slot index=%d label=%s because parsed hours<=0", idx, slot_str)
            continue
        if force_start_based_window:
            slot_start_offset = prev_slot_end
            slot_end_offset = slot_hours
        else:
            # 限制在实验的有效范围内
            slot_end_offset = min(slot_hours, total_duration)
            slot_start_offset = min(prev_slot_end, total_duration)
            if slot_end_offset <= slot_start_offset:
                LOGGER.debug(
                    "Skip slot index=%d label=%s because end_offset<=start_offset (%.3f<=%.3f)",
                    idx,
                    slot_str,
                    slot_end_offset,
                    slot_start_offset,
                )
                prev_slot_end = max(prev_slot_end, slot_end_offset)
                continue

        slot_start = start_time + timedelta(hours=slot_start_offset)
        slot_end = start_time + timedelta(hours=slot_end_offset)

        if not force_start_based_window:
            # 确保不超过总结束时间
            if slot_start >= end_time:
                LOGGER.debug(
                    "Skip slot index=%d label=%s start>=end (%s>=%s)",
                    idx,
                    slot_str,
                    slot_start.isoformat(),
                    end_time.isoformat(),
                )
                continue
            if slot_end > end_time:
                slot_end = end_time

        LOGGER.debug(
            "Slot index=%d label=%s offsets=%.3f→%.3f actual=%s→%s",
            idx,
            slot_str,
            slot_start_offset,
            slot_end_offset,
            slot_start.isoformat(),
            slot_end.isoformat(),
        )

        if force_start_based_window:
            prev_slot_end = max(prev_slot_end, slot_hours)
        else:
            prev_slot_end = max(prev_slot_end, slot_end_offset)

        # 查询每个字段在当前时间点的瞬时值
        # 使用slot_end作为目标时间点（即累计时间点，如0.5h, 1h, 1.5h等）
        target_time_point = slot_end
        
        for field_name, entry in query_targets:
            result_key = entry.get("result_key") or field_name
            if not result_key:
                result_key = field_name
            entry_filters = entry.get("filters") if isinstance(entry, dict) else None
            if result_key not in temperature_data:
                temperature_data[result_key] = {}

            # 使用索引作为key，因为可能有重复的时间刻度
            slot_key = f"{idx}_{slot_str}"  # 使用索引+时间刻度作为唯一key

            # 查询瞬时值：传入相同的时间点作为start和end，函数内部会处理为查找最近的数据点
            value = _query_influxdb(
                field_name,
                target_time_point,  # start_time参数（函数内部不使用）
                target_time_point,  # end_time参数（作为目标时间点）
                influx_url,
                influx_org,
                influx_token,
                influx_bucket,
                influx_measurement,
                filters=entry_filters if entry_filters else None,
            )

            if value is not None:
                temperature_data[result_key][slot_key] = value
                LOGGER.debug(
                    "Field=%s result_key=%s slot=%s value=%.3f",
                    field_name,
                    result_key,
                    slot_key,
                    value,
                )
            else:
                LOGGER.debug(
                    "Field=%s result_key=%s slot=%s yielded no data",
                    field_name,
                    result_key,
                    slot_key,
                )
        prev_slot_end = slot_end_offset
    return temperature_data
def build_temperature_table(_: Dict[str, Any]) -> Dict[str, Any]:
    token = os.environ.get("TABLE_TOKEN", "scriptTable1")
    row_offset = int(os.environ.get("TABLE_START_ROW", "0") or 0)
    col_offset = int(os.environ.get("TABLE_START_COL", "0") or 0)
    motor_speed = os.environ.get("TABLE_MOTOR_SPEED", "980RPM")
    # 解析实验时间范围
    start_str = os.environ.get("EXPERIMENT_START", "").strip()
    end_str = os.environ.get("EXPERIMENT_END", "").strip()
    start_time: Optional[datetime] = None
    end_time: Optional[datetime] = None
    if start_str:
        try:
            # 支持多种时间格式
            for fmt in ["%Y-%m-%dT%H:%M:%SZ"]:
                try:
                    start_time = datetime.strptime(start_str, fmt).astimezone(tz=None)
                    break
                except ValueError:
                    continue
        except Exception as e:
            print(f"Warning: Failed to parse EXPERIMENT_START '{start_str}': {e}", file=sys.stderr)
    if end_str:
        try:
            for fmt in ["%Y-%m-%dT%H:%M:%SZ"]:
                try:
                    end_time = datetime.strptime(end_str, fmt).astimezone(tz=None)
                    break
                except ValueError:
                    continue
        except Exception as e:
            print(f"Warning: Failed to parse EXPERIMENT_END '{end_str}': {e}", file=sys.stderr)
    time_slots = _time_slots()
    sections = _default_sections()
    # 查询温度数据
    temperature_data = _load_temperature_data(time_slots, sections, start_time, end_time)
    # 始终禁止默认数据，保证查询不到值时保持空白
    use_defaults = False
    cells = _build_cells(
        time_slots, 
        sections, 
        motor_speed, 
        start_time, 
        end_time, 
        temperature_data,
        use_defaults=use_defaults
    )
    for cell in cells:
        cell["row"] += 4
    start_time_row = 1
    start_time_value_col = 1
    end_time_value_col = 3
    utc_aware_dt = datetime.strptime(start_str, "%Y-%m-%dT%H:%M:%S%z")
    local_dt1 = utc_aware_dt.astimezone(tz=None)
    local_dt2 = utc_aware_dt.astimezone(tz=None) + timedelta(hours=3.5)
    start_time_value = local_dt1.strftime("%Y-%m-%d %H:%M:%S")
    end_time_value = local_dt2.strftime("%Y-%m-%d %H:%M:%S")
    cells.append({"row": start_time_row, "col": start_time_value_col, "value": start_time_value})
    cells.append({"row": start_time_row, "col": end_time_value_col, "value": end_time_value}) 
    influx_url = os.environ.get("INFLUX_URL", "").strip()
    influx_org = os.environ.get("INFLUX_ORG", "").strip()
    influx_token = os.environ.get("INFLUX_TOKEN", "").strip()
    influx_bucket = os.environ.get("INFLUX_BUCKET", "PCM").strip()
    influx_measurement = os.environ.get("INFLUX_MEASUREMENT", "PCM_Measurement").strip()
    value = _query_influxdb(
                "环境温度",
                start_time,
                end_time,
                influx_url,
                influx_org,
                influx_token,
                influx_bucket,
                influx_measurement,
                filters={"data_type": "LSDAQ"},
            )
    # 确保value不是None，避免Word COM操作异常
    if value is not None:
        cells.append({"row": 0, "col": 1, "value": f"{value:.1f}"})
    else:
        cells.append({"row": 0, "col": 1, "value": ""})    
    return {
        "token": token,
        "startRow": row_offset,
        "startCol": col_offset,
        "cells": cells,
    }
def main() -> int:
    try:
        try:
            if not logging.getLogger().handlers:
                log_level_name = os.environ.get("TABLE_LOG_LEVEL", "DEBUG").strip() or "DEBUG"
                log_level = getattr(logging, log_level_name.upper(), logging.DEBUG)
                log_file_raw = os.environ.get("TABLE_LOG_FILE", "test.log").strip() or "test.log"
                log_file = os.path.abspath(log_file_raw)

                logging.basicConfig(
                    level=log_level,
                    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
                    handlers=[
                        logging.FileHandler(log_file, encoding="utf-8"),
                        logging.StreamHandler(sys.stderr),
                    ],
                )
                LOGGER.info("Logging initialized -> file=%s level=%s", log_file, logging.getLevelName(log_level))
                _log_environment_variables()
            sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
        except Exception:
            pass
        payload = _load_payload()
        table_spec = build_temperature_table(payload)
        result = {"tables": [table_spec]}
        print(json.dumps(result, ensure_ascii=False))
        return 0
    except Exception as exc:
        print(f"error: {exc}", file=sys.stderr)
        return 1
if __name__ == "__main__":
    sys.exit(main())