CloudHome-Ops/lib/services/org_service.dart

import 'package:dio/dio.dart';
import 'package:flutter/foundation.dart';
import 'package:image_picker/image_picker.dart';

import '../models/org_node.dart';
import '../models/store_config.dart';
import '../models/store_info.dart';
import '../utils/session_org_scope.dart';
import '../utils/store_local_cache.dart';
import 'api_client.dart';
import 'upload_service.dart';

/// 组织与门店管理服务：组织树、门店、设备分组查询。
///
/// 对接真实「爱视后台」/api/sys/org/* 与 /api/sys/store/* 接口。
/// 响应已由 [ApiInterceptor] 解包 `{code,msg,data}` 信封，直接消费 data。
class OrgService {
  OrgService({Dio? dio}) : _dio = dio ?? ApiClient.instance.dio;

  final Dio _dio;

  // ================ 组织管理 ================

  /// 获取组织树（全量树形结构，当前用户可见范围）。
  ///
  /// GET /sys/org/tree
  ///
  /// 注：后端该接口在部分部署下会返回**全量**组织树，不做数据权限收敛，
  /// 因此这里在客户端按 [SessionOrgScope] 把树裁剪到「当前登录用户所属组织
  /// 子树」（含自身与全部后代）。[SessionOrgScope] 未启用（管理员 / orgId 为空）
  /// 时原样返回，行为与后端保持一致。
  Future<List<OrgNode>> getOrgTree() async {
    final response = await _dio.get<dynamic>('/sys/org/tree');
    final list = _extractList(response.data);
    final tree = list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
    return _scopeTree(tree);
  }

  /// 获取组织列表（分页）。
  ///
  /// GET /sys/org/list?page=&limit=
  Future<List<OrgNode>> getOrgList({
    int page = 1,
    int limit = 20,
  }) async {
    final response = await _dio.get<dynamic>(
      '/sys/org/list',
      queryParameters: {'page': page, 'limit': limit},
    );
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
  }

  /// 获取组织扁平列表（不分页，用于下拉选择）。
  ///
  /// GET /sys/org/flatList
  ///
  /// 命中 [SessionOrgScope] 时，仅保留当前用户组织子树内的节点，
  /// 避免下拉选项出现其他组织的越权数据。
  Future<List<OrgNode>> getOrgFlatList() async {
    final response = await _dio.get<dynamic>('/sys/org/flatList');
    final list = _extractList(response.data);
    final all = list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
    final scope = SessionOrgScope.instance;
    if (!scope.enabled) return all;
    final ids = await scopedOrgIdSet();
    if (ids.isEmpty) return all;
    return all.where((n) => ids.contains(n.id)).toList();
  }

  /// 获取组织下拉选项（同扁平列表，语义区分）。
  ///
  /// GET /sys/org/select
  ///
  /// 同样受 [SessionOrgScope] 收敛，仅返回当前用户组织子树内的节点。
  Future<List<OrgNode>> getOrgSelect() async {
    final response = await _dio.get<dynamic>('/sys/org/select');
    final list = _extractList(response.data);
    final all = list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
    final scope = SessionOrgScope.instance;
    if (!scope.enabled) return all;
    final ids = await scopedOrgIdSet();
    if (ids.isEmpty) return all;
    return all.where((n) => ids.contains(n.id)).toList();
  }

  /// 获取组织详情。
  ///
  /// GET /sys/org/info/{id}
  Future<OrgNode> getOrgInfo(String id) async {
    final response = await _dio.get<dynamic>('/sys/org/info/$id');
    final data = response.data;
    if (data is! Map<String, dynamic>) {
      throw ApiException(500, '组织信息加载失败：$id');
    }
    return OrgNode.fromJson(data);
  }

  /// 获取渠道列表（type=1 的组织节点）。
  ///
  /// GET /sys/org/channels
  Future<List<OrgNode>> getOrgChannels() async {
    final response = await _dio.get<dynamic>('/sys/org/channels');
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
  }

  /// 获取渠道下的代理商树（渠道 → 代理商 → 门店）。
  ///
  /// GET /sys/org/channelAgentTree?channelId={channelId}
  ///
  /// 注：与 Web 后台 [org.ts] 的 [getChannelAgentTree] 严格一致——channelId 走
  /// **查询参数**而非路径段（早期误写成 /channelAgentTree/{id} 会导致后端取不到
  /// 渠道、代理树加载为空）。
  Future<List<OrgNode>> getChannelAgentTree(String channelId) async {
    final response = await _dio.get<dynamic>(
      '/sys/org/channelAgentTree',
      queryParameters: {'channelId': channelId},
    );
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
  }

  /// 获取「渠道商管理」统一树（渠道 → 代理/子代理）。
  ///
  /// 后端无单一渠道商全量树接口，此处组合两个既有接口：
  /// 1. GET /sys/org/channels 拉顶层渠道列表；
  /// 2. 对每个渠道 GET /sys/org/channelAgentTree?channelId=xxx 拉其下代理/子代理树。
  ///
  /// **降级策略**：若 /sys/org/channels 失败（部分部署下该端点可能返回服务端异常
  /// 或权限错误），自动回退到 GET /sys/org/tree（全量组织树，已在门店列表中验证可用），
  /// 从中提取 type=1（渠道）与 type=2（代理）节点及其子树，保证页面不白屏。
  ///
  /// 单渠道 agentTree 请求失败不影响整体（该渠道降级为无子节点），其余渠道正常展示。
  /// 结果按渠道 orderNo 升序、渠道内子节点递归按 orderNo 升序，便于稳定展示。
  Future<List<OrgNode>> getChannelTree() async {
    // 主路径：/sys/org/channels + /sys/org/channelAgentTree
    try {
      final channels = await getOrgChannels();
      final tree = <OrgNode>[];
      for (final channel in channels) {
        List<OrgNode> agents = const <OrgNode>[];
        try {
          agents = await getChannelAgentTree(channel.id);
        } catch (_) {
          // 单渠道拉取失败：降级为无子节点，继续后续渠道。
        }
        tree.add(channel.copyWith(children: _sortTree(agents)));
      }
      tree.sort(_byOrderNo);
      if (tree.isNotEmpty) return tree;
    } catch (e) {
      debugPrint('[OrgService.getChannelTree] /sys/org/channels 主路径失败: $e');
    }

    // 降级路径：从全量组织树递归提取渠道/代理节点。
    try {
      final orgTree = await getOrgTree();
      final fallback = _collectChannelNodes(orgTree);
      if (fallback.isNotEmpty) {
        debugPrint(
          '[OrgService.getChannelTree] 已从 /sys/org/tree 降级加载 '
          '${fallback.length} 个渠道/代理节点',
        );
        return _sortTree(fallback);
      }
    } catch (e) {
      debugPrint('[OrgService.getChannelTree] 降级路径也失败: $e');
    }

    // 双路径均失败：抛出原始异常让 UI 展示错误。
    throw ApiException(500, '无法加载渠道数据，请检查网络或联系管理员');
  }

  /// 从组织树中**递归**收集渠道(type=1)/代理(type=2) 节点，保留它们之间的层级关系。
  ///
  /// 平台(type=0)/门店(type=3)/分组(type=4) 等非渠道节点作为「过路节点」被跳过
  /// （不单独展示），但其下方若含有渠道/代理则继续下钻——确保即使组织树的
  /// 顶层是平台节点（type=0），其下的渠道与代理仍能被正确提取。
  ///
  /// 例：平台 → 渠道A → 代理B → 门店C → 代理D
  /// 提取结果：[渠道A(子=[代理B(子=[代理D])])]
  static List<OrgNode> _collectChannelNodes(List<OrgNode> nodes) {
    final result = <OrgNode>[];
    for (final node in nodes) {
      if (node.type == 1 || node.type == 2) {
        // 渠道/代理：保留自身，递归过滤子孙仅保留渠道/代理支系。
        result.add(node.copyWith(children: _collectChannelNodes(node.children)));
      } else {
        // 非渠道节点：跳过自身，但透传其下方可能含渠道/代理的分支。
        if (node.children.isNotEmpty) {
          result.addAll(_collectChannelNodes(node.children));
        }
      }
    }
    return result;
  }

  /// 递归按 orderNo 升序排序树（节点及各级子节点）。
  static List<OrgNode> _sortTree(List<OrgNode> nodes) {
    final sorted = [...nodes]..sort(_byOrderNo);
    return sorted
        .map((n) => n.copyWith(children: _sortTree(n.children)))
        .toList();
  }

  /// 按 orderNo 升序的比较器（orderNo 相同再按 id 兜底，保证稳定）。
  static int _byOrderNo(OrgNode a, OrgNode b) {
    if (a.orderNo != b.orderNo) return a.orderNo.compareTo(b.orderNo);
    return a.id.compareTo(b.id);
  }

  /// 新增门店 / 组织。
  ///
  /// POST /sys/org/save，body **不带 id/orgId**（带 id 会走 insert 分支，
  /// 报「数据库中已存在该记录」；只带 orgId 会被忽略而误建新记录）。
  /// 门店为 type='STORE'，且**必填 province**，否则报「门店省份不能为空」。
  /// 返回后端 data 中的 orgId（新增门店时可用于后续创建激活码等）。
  Future<String?> createOrg(Map<String, dynamic> data) async {
    final payload = Map<String, dynamic>.from(data);
    // 新增必须剥离主键，防止后端误判为更新或重复插入。
    payload.remove('id');
    payload.remove('orgId');
    final response = await _dio.post<dynamic>('/sys/org/save', data: payload);
    final result = response.data;
    if (result is Map<String, dynamic>) {
      return result['orgId']?.toString() ?? result['id']?.toString();
    }
    if (result is String) return result;
    return null;
  }

  /// 修改门店 / 组织。
  ///
  /// POST /sys/org/update，后端**只认 id**（传 orgId 会报「组织不存在」），
  /// 因此强制以 id 为主键并剥离 orgId，避免编辑被误判。
  /// 返回后端 data 中的 orgId。
  Future<String?> updateOrg(Map<String, dynamic> data) async {
    final payload = Map<String, dynamic>.from(data);
    // 后端 update 仅使用 id；orgId 会被忽略甚至触发「组织不存在」，必须剥离。
    final id = (data['id'] ?? data['orgId'])?.toString() ?? '';
    payload.remove('orgId');
    payload['id'] = id;
    final response = await _dio.post<dynamic>('/sys/org/update', data: payload);
    final result = response.data;
    if (result is Map<String, dynamic>) {
      return result['orgId']?.toString() ?? result['id']?.toString();
    }
    if (result is String) return result;
    return null;
  }

  /// 新增或修改组织（兼容旧调用方，如组织树页面）。
  ///
  /// 注意：后端**未注册** `/sys/org/saveOrUpdate` 路由，调用必返回
  /// 「未知异常，请联系管理员」。故按 body 是否携带 id/orgId 自动分流到
  /// [createOrg]（新增）或 [updateOrg]（编辑）。
  Future<String?> saveOrUpdateOrg(Map<String, dynamic> data) async {
    final isEdit = (data['id'] != null && data['id'].toString().isNotEmpty) ||
        (data['orgId'] != null && data['orgId'].toString().isNotEmpty);
    return isEdit ? updateOrg(data) : createOrg(data);
  }

  /// 删除组织（含子节点校验）。
  ///
  /// POST /sys/org/delete/{id}
  Future<void> deleteOrg(String id) async {
    await _dio.post<dynamic>('/sys/org/delete/$id');
  }

  // ================ 门店管理 ================

  /// 获取当前登录用户可见的门店列表。
  ///
  /// 排序 / 展示需与 Web 后台「门店管理」保持一致：Web 后台门店管理读取的是
  /// 组织树（门店专用接口 /sys/store/* 在该账号下多返回 500，不可用），故
  /// 第 1 步直接读组织树并递归收集 type=3 门店，同时透传节点的 [OrgNode.createdAt]
  /// 作为 [StoreInfo.createTime] 供「建店时间倒序」使用；门店专用接口仅作兜底。
  ///
  /// 回退链（任一成功且非空即用）：
  /// 1. 组织树 GET /sys/org/tree，递归收集 type=3 门店（透传 createdAt）；
  /// 2. 门店专用 GET /sys/store/myStores；
  /// 3. 登录组织门店 GET /sys/store/listByLoginOrg。
  Future<List<StoreInfo>> getMyStores() async {
    // 第 1 步：组织树（与 Web 后台门店管理同源，且透传 createdAt）。
    try {
      final tree = await getOrgTree();
      final stores = _collectStores(tree);
      if (stores.isNotEmpty) return stores;
    } catch (_) {
      // 继续回退。
    }
    // 第 2 步：myStores。
    try {
      final response = await _dio.get<dynamic>('/sys/store/myStores');
      final list = _extractList(response.data);
      final stores = list
          .whereType<Map<String, dynamic>>()
          .map(StoreInfo.fromJson)
          .toList();
      if (stores.isNotEmpty) return stores;
    } catch (_) {
      // 继续回退。
    }
    // 第 3 步：按登录组织查门店。
    try {
      final stores = await getStoreListByLoginOrg();
      if (stores.isNotEmpty) return stores;
    } catch (_) {
      // 全部失败，返回空。
    }
    return const <StoreInfo>[];
  }

  /// 统计门店数量（type=3）。
  ///
  /// 复用 [getMyStores] 的回退链，确保门店总数与门店列表一致，
  /// 避免组织树异常时直接返回 0 导致「门店总数=0」的问题。
  Future<int> fetchStoreCount() async {
    try {
      return (await getMyStores()).length;
    } catch (_) {
      return 0;
    }
  }

  /// 递归把组织树扁平化，并过滤出门店（type=3 或 type='STORE'）。
  ///
  /// 新接口 /sys/org/tree 返回的 type 为字符串（CHANNEL/SERVICE_PROVIDER/STORE/GROUP），
  /// 经 [OrgNode.fromJson] 已映射为 int，但此处兼容判断字符串更保险。
  ///
  /// 组织树节点通常不携带 [parentId]，而是通过 [children] 嵌套表达层级；
  /// 因此递归时把当前节点 [id] 作为子节点的 [parentId] 传入，确保门店的
  /// [StoreInfo.parentId] 能正确指向其在树中的直接父组织（渠道/代理商）。
  static List<StoreInfo> _collectStores(List<OrgNode> nodes, {String parentId = ''}) {
    final stores = <StoreInfo>[];
    for (final node in nodes) {
      final isStore = node.type == 3 || node.type.toString().toUpperCase() == 'STORE';
      if (isStore) {
        final province = node.province.trim();
        final city = node.city.trim();
        final address = node.address.trim();
        final fullAddress = <String>[];
        if (province.isNotEmpty) fullAddress.add(province);
        if (city.isNotEmpty) fullAddress.add(city);
        if (address.isNotEmpty) fullAddress.add(address);
        // 优先使用节点自身携带的 parentId；树接口未返回时，使用递归上下文中的父节点 ID。
        final effectiveParentId = node.parentId.isNotEmpty ? node.parentId : parentId;
        stores.add(
          StoreInfo(
            orgId: node.id,
            parentId: effectiveParentId.isEmpty ? null : effectiveParentId,
            name: node.name,
            address: fullAddress.join(''),
            contactPhone: node.contactPhone,
            activationCode: node.activationCode,
            status: 0,
            // 透传组织树节点的到期时间（部分部署的 /sys/org/tree 会返回
            // expireTime/expire_time；缺失则为 null，列表项将据此显示「无到期时间」）。
            expireTime: node.expireTime,
            createTime: node.createdAt,
            deviceLimit: node.groupLimit,
            // 新接口 /sys/org/tree 返回的 themeId（如 35/36/37），
            // 转为字符串供前端 StoreThemePresets 匹配或回显。
            themeId: node.themeId?.toString(),
          ),
        );
      }
      if (node.children.isNotEmpty) {
        stores.addAll(_collectStores(node.children, parentId: node.id));
      }
    }
    return stores;
  }

  /// 按组织 ID 获取门店列表。
  ///
  /// GET /sys/store/byOrgId/{orgId}
  Future<List<StoreInfo>> getStoresByOrgId(String orgId) async {
    final response =
        await _dio.get<dynamic>('/sys/store/byOrgId/$orgId');
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(StoreInfo.fromJson)
        .toList();
  }

  /// 按门店 ID 获取设备分组列表。
  ///
  /// GET /sys/store/deviceGroups/{storeId}
  Future<List<OrgNode>> getDeviceGroupsByStoreId(String storeId) async {
    final response =
        await _dio.get<dynamic>('/sys/store/deviceGroups/$storeId');
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(OrgNode.fromJson)
        .toList();
  }

  /// 门店搜索（分页，支持多条件筛选）。
  ///
  /// GET /sys/store/search?page=&limit=&orgId=&name=&status=
  ///
  /// 未显式传入 [orgId] 时，自动带上 [SessionOrgScope] 的当前用户组织，
  /// 防止未指定组织时越权查询到其他组织的门店（[SessionOrgScope] 未启用时
  /// 不附加，保留管理员全量查询能力）。
  Future<List<StoreInfo>> searchStore({
    int page = 1,
    int limit = 20,
    String? orgId,
    String? name,
    int? status,
  }) async {
    final effectiveOrgId = orgId ??
        (SessionOrgScope.instance.enabled
            ? SessionOrgScope.instance.currentOrgId
            : null);
    final response = await _dio.get<dynamic>(
      '/sys/store/search',
      queryParameters: {
        'page': page,
        'limit': limit,
        if (effectiveOrgId != null) 'orgId': effectiveOrgId,
        if (name != null) 'name': name,
        if (status != null) 'status': status,
      },
    );
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(StoreInfo.fromJson)
        .toList();
  }

  /// 获取当前登录组织下的门店列表（可按名称模糊查询）。
  ///
  /// GET /sys/store/listByLoginOrg?name=
  Future<List<StoreInfo>> getStoreListByLoginOrg({String? name}) async {
    final response = await _dio.get<dynamic>(
      '/sys/store/listByLoginOrg',
      queryParameters: {
        if (name != null) 'name': name,
      },
    );
    final list = _extractList(response.data);
    return list
        .whereType<Map<String, dynamic>>()
        .map(StoreInfo.fromJson)
        .toList();
  }

  /// 查询门店配置（到期时间 / 禁用状态等）。
  ///
  /// GET /device/storeConfig/info/{orgId}
  ///
  /// 与 Web 后台「门店配置」弹窗同源（screen-front `getStoreConfig`）。
  /// 组织树与通用门店列表接口通常不返回 `expireTime`，门店的到期时间必须由此
  /// 端点补全——列表/详情均用它做权威兜底。接口异常或无数据返回 [StoreConfig.empty]。
  Future<StoreConfig> getStoreConfig(String orgId) async {
    try {
      final response =
          await _dio.get<dynamic>('/device/storeConfig/info/$orgId');
      final data = response.data;
      if (data is! Map<String, dynamic>) return StoreConfig.empty();
      return StoreConfig.fromJson(data);
    } catch (_) {
      return StoreConfig.empty();
    }
  }

  // ================ 门店扩展字段（前端占位） ================

  /// 新增或更新门店（含主题/品牌/省市区等扩展字段）。
  ///
  /// 门店本质上是 type='STORE' 的组织节点。按是否携带 id/orgId 分流：
  /// - 新增 → [createOrg]（POST /sys/org/save，不带主键，必填 province）；
  /// - 编辑 → [updateOrg]（POST /sys/org/update，只认 id）。
  /// 返回后端生成的 orgId（新增门店时可用于创建激活码）。
  Future<String?> saveStore(Map<String, dynamic> data) async {
    // 真实上报后端（新增/编辑分流到正确路由）。
    final isEdit = (data['id'] != null && data['id'].toString().isNotEmpty) ||
        (data['orgId'] != null && data['orgId'].toString().isNotEmpty);
    final result = isEdit ? updateOrg(data) : createOrg(data);
    // 扩展字段写本地缓存：用真实 orgId 回填，避免新建时因 orgId 为空而丢失
    // 主题/品牌/省市区等建店配置（Web 端同源，移动端本地兜底回显）。
    final realOrgId = (result ?? data['orgId'] ?? data['id'])?.toString() ?? '';
    if (realOrgId.isNotEmpty) {
      final ext = Map<String, dynamic>.from(data)..['orgId'] = realOrgId;
      await _persistStoreExtension(ext);
    }
    return result;
  }

  /// 更新门店（含扩展字段）。
  ///
  /// 固定走 [updateOrg]（POST /sys/org/update，只认 id）。
  Future<String?> updateStore(Map<String, dynamic> data) async {
    final result = updateOrg(data);
    final realOrgId = (result ?? data['orgId'] ?? data['id'])?.toString() ?? '';
    if (realOrgId.isNotEmpty) {
      final ext = Map<String, dynamic>.from(data)..['orgId'] = realOrgId;
      await _persistStoreExtension(ext);
    }
    return result;
  }

  /// 设置门店主题皮肤。
  ///
  /// 本地缓存兜底（离线回显）+ 上报后端 `POST /sys/store/setTheme`。
  /// 上报失败时异常向外传播，由调用方决定提示策略（门店列表页会静默忽略，
  /// 不影响门店本身已保存的结果）。
  Future<void> setStoreTheme(String orgId, String themeId) async {
    // 本地缓存兜底：即使上报失败，本机回显仍可用。
    await StoreLocalCache.instance.saveTheme(orgId, themeId);
    await _dio.post<dynamic>(
      '/sys/store/setTheme',
      data: {'orgId': orgId, 'themeId': themeId},
    );
  }

  /// 设置门店启动图/Logo。
  ///
  /// [splashUrl]/[logoUrl] 可以是：
  /// - 远程 URL（http/https 开头）→ 直接上报；
  /// - 本地文件路径 → 先经 [UploadService.uploadImage] 上传拿 CDN URL 再上报。
  ///
  /// 本地缓存兜底（离线回显）+ 上报后端 `POST /sys/store/setBranding`。
  Future<void> setStoreBranding(
    String orgId,
    String splashUrl,
    String logoUrl,
  ) async {
    // 本地缓存兜底。
    await StoreLocalCache.instance.saveBranding(orgId, splashUrl, logoUrl);

    final upload = UploadService();
    Future<String> resolve(String raw) async {
      if (raw.isEmpty) return raw;
      // 已是远程 URL 直接复用；否则当作本地路径上传拿 CDN URL。
      if (raw.startsWith('http://') || raw.startsWith('https://')) return raw;
      return upload.uploadImage(XFile(raw), mediaType: 'image');
    }

    final splash = await resolve(splashUrl);
    final logo = await resolve(logoUrl);
    await _dio.post<dynamic>(
      '/sys/store/setBranding',
      data: {'orgId': orgId, 'splashUrl': splash, 'logoUrl': logo},
    );
  }

  /// 设置门店省市区归属与详细地址。
  ///
  /// 本地缓存兜底（离线回显）+ 上报后端 `POST /sys/store/setRegion`。
  Future<void> setRegion(
    String orgId,
    String provinceCode,
    String cityCode,
    String districtCode,
    String addressDetail,
  ) async {
    await StoreLocalCache.instance.saveRegion(
      orgId,
      provinceCode,
      cityCode,
      districtCode,
      addressDetail,
    );
    await _dio.post<dynamic>(
      '/sys/store/setRegion',
      data: {
        'orgId': orgId,
        'provinceCode': provinceCode,
        'cityCode': cityCode,
        'districtCode': districtCode,
        'addressDetail': addressDetail,
      },
    );
  }

  /// 把门店扩展字段写入本地缓存（[data] 缺省字段忽略）。
  Future<void> _persistStoreExtension(Map<String, dynamic> data) async {
    final orgId = (data['orgId'] ?? data['id'])?.toString() ?? '';
    if (orgId.isEmpty) return;
    final themeId = data['themeId']?.toString();
    if (themeId != null && themeId.isNotEmpty) {
      await StoreLocalCache.instance.saveTheme(orgId, themeId);
    }
    final splashUrl = data['splashUrl']?.toString() ?? '';
    final logoUrl = data['logoUrl']?.toString() ?? '';
    if (splashUrl.isNotEmpty || logoUrl.isNotEmpty) {
      await StoreLocalCache.instance.saveBranding(orgId, splashUrl, logoUrl);
    }
    final provinceCode = data['provinceCode']?.toString() ?? '';
    final cityCode = data['cityCode']?.toString() ?? '';
    final districtCode = data['districtCode']?.toString() ?? '';
    final addressDetail = data['addressDetail']?.toString() ?? '';
    if (provinceCode.isNotEmpty ||
        cityCode.isNotEmpty ||
        districtCode.isNotEmpty ||
        addressDetail.isNotEmpty) {
      await StoreLocalCache.instance.saveRegion(
        orgId,
        provinceCode,
        cityCode,
        districtCode,
        addressDetail,
      );
    }
  }

  // ================ 工具方法 ================

  /// 在组织树中按节点 ID 深度优先查找节点。
  static OrgNode? _findNode(List<OrgNode> nodes, String target) {
    for (final n in nodes) {
      if (n.id == target) return n;
      final found = _findNode(n.children, target);
      if (found != null) return found;
    }
    return null;
  }

  /// 收集某节点（含自身）的全部后代 ID（深度优先，含 root 本身）。
  ///
  /// 用于组织树筛选：选中某个渠道 / 代理商 / 分组后，命中其下所有层级的门店。
  /// 找不到 [rootId] 对应节点时返回空集合。
  ///
  /// [nodes] 为已按 [SessionOrgScope] 收敛的组织树（[getOrgTree] 返回值）。
  static Set<String> collectDescendantIds(List<OrgNode> nodes, String rootId) {
    final root = _findNode(nodes, rootId);
    final ids = <String>{};
    void walk(List<OrgNode> ns) {
      for (final n in ns) {
        ids.add(n.id);
        walk(n.children);
      }
    }

    if (root != null) walk([root]);
    return ids;
  }

  /// 收集某节点（含自身）的全部后代中「门店（type=3）」的 ID。
  ///
  /// 与 [collectDescendantIds] 的区别：仅收集门店节点，过滤掉渠道/代理/分组等
  /// 非门店节点，便于直接作为 `/device/info/list` 的 `storeOrgId` 入参集合使用。
  /// 找不到 [rootId] 对应节点时返回空集合。
  static Set<String> collectDescendantStoreIds(
    List<OrgNode> nodes,
    String rootId,
  ) {
    final root = _findNode(nodes, rootId);
    final ids = <String>{};
    void walk(List<OrgNode> ns) {
      for (final n in ns) {
        if (n.type == 3) ids.add(n.id);
        walk(n.children);
      }
    }

    if (root != null) walk([root]);
    return ids;
  }

  /// 将组织树收敛到「当前登录用户所属组织子树」（含自身与全部后代）。
  ///
  /// - 未启用 [SessionOrgScope]（管理员 / orgId 为空）：原样返回。
  /// - 已启用但树中找不到对应节点：兜底原样返回，避免误清空。
  ///
  /// 这样即便后端 `/sys/org/tree` 返回全量树，非管理员用户也只能看到
  /// 自己组织及下属门店的数据。
  static List<OrgNode> _scopeTree(List<OrgNode> tree) {
    final scope = SessionOrgScope.instance;
    if (!scope.enabled) return tree;
    final root = _findNode(tree, scope.currentOrgId);
    // 兜底：找不到当前组织节点时不过滤（避免误清空导致白屏），
    // 但打印告警以便排查「用户 orgId 与组织树节点不匹配」的数据异常。
    if (root == null) {
      debugPrint(
        '[OrgService._scopeTree] 未在组织树中找到当前组织节点 '
        '(orgId=${scope.currentOrgId})，放弃客户端收敛',
      );
      return tree;
    }
    return [root];
  }

  /// 收集「当前已收敛组织树」包含的全部节点 ID（用于裁剪扁平/下拉列表与用户列表）。
  ///
  /// 仅在 [SessionOrgScope] 启用时返回非空集合（[getOrgTree] 已按范围收敛）；
  /// 未启用时返回空集合，调用方据此跳过过滤、保持原样。
  Future<Set<String>> scopedOrgIdSet() async {
    final scope = SessionOrgScope.instance;
    if (!scope.enabled) return const {};
    final tree = await getOrgTree();
    final ids = <String>{};
    void collect(List<OrgNode> nodes) {
      for (final n in nodes) {
        ids.add(n.id);
        collect(n.children);
      }
    }

    collect(tree);
    return ids;
  }

  /// 兼容列表响应的三种形态：
  /// `{list: [...], totalCount}` / `{page: {list, totalCount}}` / 直接数组。
  static List<dynamic> _extractList(dynamic data) {
    if (data is List) {
      return data;
    }
    if (data is Map<String, dynamic>) {
      final list = data['list'];
      if (list is List) {
        return list;
      }
      final page = data['page'];
      if (page is Map<String, dynamic> && page['list'] is List) {
        return page['list'] as List;
      }
    }
    return const <dynamic>[];
  }
}