from __future__ import annotations

from typing import Annotated

import typer

from .apps import (
    data_extension_app,
    data_misc_app,
    data_scada_app,
    data_scheme_app,
    data_timeseries_composite_app,
    data_timeseries_realtime_app,
    data_timeseries_scada_app,
    data_timeseries_scheme_app,
)
from .common import emit_api, runtime_context
from .core import CLIError, parse_time_with_timezone, require_network, resolve_scheme


def _scheme_type_option(scheme_type: str | None) -> str:
    return scheme_type or "simulation"


@data_timeseries_realtime_app.command("links")
def data_realtime_links(
    ctx: typer.Context,
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
) -> None:
    emit_api(
        ctx,
        summary="读取实时管道数据成功",
        method="GET",
        path="/realtime/links",
        params={
            "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
            "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_realtime_app.command("nodes")
def data_realtime_nodes(
    ctx: typer.Context,
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
) -> None:
    emit_api(
        ctx,
        summary="读取实时节点数据成功",
        method="GET",
        path="/realtime/nodes",
        params={
            "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
            "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_realtime_app.command("simulation-by-id-time")
def data_realtime_simulation_by_id_time(
    ctx: typer.Context,
    id: Annotated[str, typer.Option("--id", help="元素 ID")],
    type: Annotated[str, typer.Option("--type", help="pipe|junction")],
    time: Annotated[str, typer.Option("--time", help="查询时间")],
) -> None:
    emit_api(
        ctx,
        summary="读取实时模拟数据成功",
        method="GET",
        path="/realtime/query/by-id-time",
        params={
            "id": id,
            "type": type,
            "query_time": parse_time_with_timezone(time, option_name="--time").isoformat(),
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_realtime_app.command("simulation-by-time-property")
def data_realtime_simulation_by_time_property(
    ctx: typer.Context,
    type: Annotated[str, typer.Option("--type", help="pipe|junction")],
    time: Annotated[str, typer.Option("--time", help="查询时间")],
    property: Annotated[str, typer.Option("--property", help="属性名")],
) -> None:
    emit_api(
        ctx,
        summary="读取实时属性聚合数据成功",
        method="GET",
        path="/realtime/query/by-time-property",
        params={
            "type": type,
            "query_time": parse_time_with_timezone(time, option_name="--time").isoformat(),
            "property": property,
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_scheme_app.command("links")
def data_scheme_links(
    ctx: typer.Context,
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
    scheme: Annotated[str | None, typer.Option("--scheme", help="方案名称")] = None,
    scheme_type: Annotated[str | None, typer.Option("--scheme-type", help="方案类型")] = None,
) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取方案管道数据成功",
        method="GET",
        path="/scheme/links",
        params={
            "scheme_name": resolve_scheme(runtime, scheme, required=True),
            "scheme_type": _scheme_type_option(scheme_type),
            "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
            "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_scheme_app.command("node-field")
def data_scheme_node_field(
    ctx: typer.Context,
    node: Annotated[str, typer.Option("--node", help="节点 ID")],
    field: Annotated[str, typer.Option("--field", help="字段名")],
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
    scheme: Annotated[str | None, typer.Option("--scheme", help="方案名称")] = None,
    scheme_type: Annotated[str | None, typer.Option("--scheme-type", help="方案类型")] = None,
) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取方案节点字段成功",
        method="GET",
        path=f"/scheme/nodes/{node}/field",
        params={
            "field": field,
            "scheme_name": resolve_scheme(runtime, scheme, required=True),
            "scheme_type": _scheme_type_option(scheme_type),
            "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
            "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
        },
        require_auth=True,
        require_project=True,
    )


@data_timeseries_scheme_app.command("simulation")
def data_scheme_simulation(
    ctx: typer.Context,
    query: Annotated[str, typer.Option("--query", help="by-id-time|by-scheme-time-property")],
    scheme: Annotated[str | None, typer.Option("--scheme", help="方案名称")] = None,
    scheme_type: Annotated[str | None, typer.Option("--scheme-type", help="方案类型")] = None,
    id: Annotated[str | None, typer.Option("--id", help="元素 ID")] = None,
    time: Annotated[str, typer.Option("--time", help="查询时间")] = "",
    type: Annotated[str, typer.Option("--type", help="pipe|junction")] = "pipe",
    property: Annotated[str | None, typer.Option("--property", help="属性名")] = None,
) -> None:
    runtime = runtime_context(ctx)
    params = {
        "scheme_name": resolve_scheme(runtime, scheme, required=True),
        "scheme_type": _scheme_type_option(scheme_type),
        "query_time": parse_time_with_timezone(time, option_name="--time").isoformat(),
        "type": type,
    }
    if query == "by-id-time":
        if not id:
            raise CLIError(
                "CLI 参数错误",
                code="ID_REQUIRED",
                message="--id is required for --query by-id-time",
                exit_code=2,
            )
        params["id"] = id
        emit_api(
            ctx,
            summary="读取方案单点模拟数据成功",
            method="GET",
            path="/scheme/query/by-id-time",
            params=params,
            require_auth=True,
            require_project=True,
        )
        return
    if query == "by-scheme-time-property":
        if not property:
            raise CLIError(
                "CLI 参数错误",
                code="PROPERTY_REQUIRED",
                message="--property is required for --query by-scheme-time-property",
                exit_code=2,
            )
        params["property"] = property
        emit_api(
            ctx,
            summary="读取方案属性聚合数据成功",
            method="GET",
            path="/scheme/query/by-scheme-time-property",
            params=params,
            require_auth=True,
            require_project=True,
        )
        return
    raise CLIError(
        "CLI 参数错误",
        code="INVALID_QUERY",
        message="--query must be by-id-time or by-scheme-time-property",
        exit_code=2,
    )


@data_timeseries_scada_app.command("query")
def data_scada_query(
    ctx: typer.Context,
    device_id: Annotated[list[str], typer.Option("--device-id", help="设备 ID，可重复")],
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
    field: Annotated[str | None, typer.Option("--field", help="字段名")] = None,
) -> None:
    path = "/scada/by-ids-field-time-range" if field else "/scada/by-ids-time-range"
    params = {
        "device_ids": ",".join(device_id),
        "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
        "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
    }
    if field:
        params["field"] = field
    emit_api(
        ctx,
        summary="读取 SCADA 时序成功",
        method="GET",
        path=path,
        params=params,
        require_auth=True,
        require_project=True,
    )


@data_timeseries_composite_app.callback(invoke_without_command=True)
def data_timeseries_composite(
    ctx: typer.Context,
    kind: Annotated[str | None, typer.Option("--kind", help="scada-simulation|element-simulation|element-scada")] = None,
    feature: Annotated[list[str] | None, typer.Option("--feature", help="特征值，可重复")] = None,
    start_time: Annotated[str | None, typer.Option("--start-time", help="开始时间")] = None,
    end_time: Annotated[str | None, typer.Option("--end-time", help="结束时间")] = None,
    pipe: Annotated[str | None, typer.Option("--pipe", help="pipeline-health 用管道 ID")] = None,
    scheme: Annotated[str | None, typer.Option("--scheme", help="方案名称")] = None,
    scheme_type: Annotated[str | None, typer.Option("--scheme-type", help="方案类型")] = None,
    use_cleaned: Annotated[bool, typer.Option("--use-cleaned", help="element-scada 使用清洗值")] = False,
) -> None:
    _ = pipe
    if ctx.invoked_subcommand is not None:
        return
    if not kind or not start_time or not end_time:
        raise CLIError(
            "CLI 参数错误",
            code="INVALID_COMPOSITE_ARGS",
            message="composite query requires --kind, --start-time, and --end-time",
            exit_code=2,
        )
    runtime = runtime_context(ctx)
    params = {
        "start_time": parse_time_with_timezone(start_time, option_name="--start-time").isoformat(),
        "end_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
    }
    if kind == "scada-simulation":
        if not feature:
            raise CLIError(
                "CLI 参数错误",
                code="FEATURE_REQUIRED",
                message="--feature is required for scada-simulation",
                exit_code=2,
            )
        params["device_ids"] = ",".join(feature)
        scheme_name = resolve_scheme(runtime, scheme)
        if scheme_name:
            params["scheme_name"] = scheme_name
            params["scheme_type"] = _scheme_type_option(scheme_type)
        emit_api(
            ctx,
            summary="读取复合 SCADA-模拟数据成功",
            method="GET",
            path="/composite/scada-simulation",
            params=params,
            require_auth=True,
            require_project=True,
        )
        return
    if kind == "element-simulation":
        if not feature:
            raise CLIError(
                "CLI 参数错误",
                code="FEATURE_REQUIRED",
                message="--feature is required for element-simulation",
                exit_code=2,
            )
        params["feature_infos"] = ",".join(feature)
        scheme_name = resolve_scheme(runtime, scheme)
        if scheme_name:
            params["scheme_name"] = scheme_name
            params["scheme_type"] = _scheme_type_option(scheme_type)
        emit_api(
            ctx,
            summary="读取复合元素模拟数据成功",
            method="GET",
            path="/composite/element-simulation",
            params=params,
            require_auth=True,
            require_project=True,
        )
        return
    if kind == "element-scada":
        if not feature or len(feature) != 1:
            raise CLIError(
                "CLI 参数错误",
                code="FEATURE_REQUIRED",
                message="element-scada requires exactly one --feature as element_id",
                exit_code=2,
            )
        params["element_id"] = feature[0]
        params["use_cleaned"] = use_cleaned
        emit_api(
            ctx,
            summary="读取元素关联 SCADA 数据成功",
            method="GET",
            path="/composite/element-scada",
            params=params,
            require_auth=True,
            require_project=True,
        )
        return
    raise CLIError(
        "CLI 参数错误",
        code="INVALID_KIND",
        message="--kind must be scada-simulation, element-simulation, or element-scada",
        exit_code=2,
    )


@data_timeseries_composite_app.command("pipeline-health")
def data_composite_pipeline_health(
    ctx: typer.Context,
    pipe: Annotated[str, typer.Option("--pipe", help="管道 ID")],
    start_time: Annotated[str, typer.Option("--start-time", help="开始时间")],
    end_time: Annotated[str, typer.Option("--end-time", help="结束时间")],
) -> None:
    _ = pipe, start_time
    emit_api(
        ctx,
        summary="读取管道健康预测成功",
        method="GET",
        path="/composite/pipeline-health-prediction",
        params={
            "network_name": require_network(runtime_context(ctx)),
            "query_time": parse_time_with_timezone(end_time, option_name="--end-time").isoformat(),
        },
        require_auth=True,
        require_project=True,
        require_network_ctx=True,
    )


def _scada_mapping(kind: str, action: str) -> tuple[str, dict[str, str]]:
    mapping = {
        ("device", "schema"): ("/getscadadeviceschema/", {}),
        ("device", "get"): ("/getscadadevice/", {"id_param": "id"}),
        ("device", "list"): ("/getallscadadevices/", {}),
        ("device-data", "schema"): ("/getscadadevicedataschema/", {}),
        ("device-data", "get"): ("/getscadadevicedata/", {"id_param": "device_id"}),
        ("element", "schema"): ("/getscadaelementschema/", {}),
        ("element", "get"): ("/getscadaelement/", {"id_param": "id"}),
        ("element", "list"): ("/getscadaelements/", {}),
        ("info", "schema"): ("/getscadainfoschema/", {}),
        ("info", "get"): ("/getscadainfo/", {"id_param": "id"}),
        ("info", "list"): ("/getallscadainfo/", {}),
    }
    result = mapping.get((kind, action))
    if result is None:
        raise CLIError(
            "CLI 参数错误",
            code="INVALID_SCADA_KIND",
            message=f"unsupported scada {action} kind: {kind}",
            exit_code=2,
        )
    return result


@data_scada_app.command("schema")
def data_scada_schema(
    ctx: typer.Context,
    kind: Annotated[str, typer.Option("--kind", help="device|device-data|element|info")],
) -> None:
    runtime = runtime_context(ctx)
    path, _ = _scada_mapping(kind, "schema")
    emit_api(
        ctx,
        summary="读取 SCADA schema 成功",
        method="GET",
        path=path,
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_scada_app.command("get")
def data_scada_get(
    ctx: typer.Context,
    kind: Annotated[str, typer.Option("--kind", help="device|device-data|element|info")],
    id: Annotated[str, typer.Option("--id", help="记录 ID")],
) -> None:
    runtime = runtime_context(ctx)
    path, meta = _scada_mapping(kind, "get")
    params = {"network": require_network(runtime), meta["id_param"]: id}
    emit_api(
        ctx,
        summary="读取 SCADA 数据成功",
        method="GET",
        path=path,
        params=params,
        require_auth=True,
        require_network_ctx=True,
    )


@data_scada_app.command("list")
def data_scada_list(
    ctx: typer.Context,
    kind: Annotated[str, typer.Option("--kind", help="device|element|info")],
) -> None:
    runtime = runtime_context(ctx)
    path, _ = _scada_mapping(kind, "list")
    emit_api(
        ctx,
        summary="读取 SCADA 列表成功",
        method="GET",
        path=path,
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_scheme_app.command("schema")
def data_scheme_schema(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取方案 schema 成功",
        method="GET",
        path="/getschemeschema/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_scheme_app.command("get")
def data_scheme_get(
    ctx: typer.Context,
    name: Annotated[str, typer.Option("--name", help="方案名称")],
) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取方案成功",
        method="GET",
        path="/getscheme/",
        params={"network": require_network(runtime), "schema_name": name},
        require_auth=True,
        require_network_ctx=True,
    )


@data_scheme_app.command("list")
def data_scheme_list(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取方案列表成功",
        method="GET",
        path="/getallschemes/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_extension_app.command("keys")
def data_extension_keys(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取扩展数据键成功",
        method="GET",
        path="/getallextensiondatakeys/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_extension_app.command("get")
def data_extension_get(
    ctx: typer.Context,
    key: Annotated[str, typer.Option("--key", help="扩展键")],
) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取扩展数据成功",
        method="GET",
        path="/getextensiondata/",
        params={"network": require_network(runtime), "key": key},
        require_auth=True,
        require_network_ctx=True,
    )


@data_extension_app.command("list")
def data_extension_list(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取扩展数据列表成功",
        method="GET",
        path="/getallextensiondata/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_misc_app.command("sensor-placements")
def data_misc_sensor_placements(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取传感器位置成功",
        method="GET",
        path="/getallsensorplacements/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )


@data_misc_app.command("burst-location-results")
def data_misc_burst_location_results(ctx: typer.Context) -> None:
    runtime = runtime_context(ctx)
    emit_api(
        ctx,
        summary="读取爆管定位结果成功",
        method="GET",
        path="/getallburstlocateresults/",
        params={"network": require_network(runtime)},
        require_auth=True,
        require_network_ctx=True,
    )