import { reqdoSQL } from '../../api/functions';

// 基本用法：传入存储过程名，返回数据
let rs = await reqdoSQL({
    sqlprocedure: 'demo1101b',  // 必须：存储过程名
    categoryid: 'A1',           // 额外参数：传给存储过程的筛选条件
    pageno: 1,                  // 分页：页码
    pagesize: 20,               // 分页：每页行数
});

// 返回值结构：
// rs.rows  → 数据行数组
// rs.error → 错误信息（空字符串表示成功）

if (rs && rs.error === '') {
    console.log(rs.rows);  // 所有数据行
    console.log(rs.rows[0]._total);  // 总记录数（分页时后端返回）
}

import { reqdoTree } from '../../api/functions';

let rs = await reqdoTree({
    sqlprocedure: 'demo804a',   // 树节点的存储过程
    style: 'expand',            // 加载方式：full=全量，expand=懒加载
    parentnodeid: '',           // 懒加载时传父节点ID
});

// 返回值结构与 reqdoSQL 相同
// rs.rows 是平级数组，需要用 toTreeData() 转成嵌套树形结构

// reqdoSQL 内部：
params.nodetype = 'datagrid';  // 告诉后端返回表格格式

// reqdoTree 内部：
params.nodetype = 'tree';      // 告诉后端返回树格式
// 实际上两者都请求同一个后端接口 /myServer/doSQL

reqdoSQL({
    sqlprocedure: 'demo1101b',
    pageno: 1,          // 对应 $pageno
    pagesize: 20,       // 对应 $pagesize
    categoryid: 'A1',   // 对应 $categoryid
})

let rs = await reqdoSQL({ sqlprocedure: '...', pageno: 1, pagesize: 20 });
let total = rs.rows[0]._total;  // 总记录数，用于显示分页控件
let data = rs.rows;              // 当前页的数据

// 前端（AntdTable 内部的 loadTableData）
loadTableData = async () => {
    let { pageno, pagesize } = this.state;

    let rs = await reqdoSQL({
        sqlprocedure: 'demo1101b',
        pageno: pageno,    // 当前页码
        pagesize: pagesize // 每页行数
    });

    // 后端返回当前页的数据 + 总记录数
    let total = rs.rows[0]._total;
    this.setState({ data: rs.rows, total });
}

// AntdTable 内部处理翻页
handlePageChange = (pageno, pagesize) => {
    this.setState({ pageno, pagesize }, () => {
        setTimeout(() => {
            this.loadTableData();  // 重新请求新的一页数据
        });
    });
}

// 存储过程保存后返回该记录在同类中的序号 rowno
let rowno = rs.rows[0].rowno;

// 根据 rowno 计算在第几页、第几行
pageno = Math.floor((rowno - 1) / pagesize) + 1;    // 页码
rowindex = rowno - (pageno - 1) * pagesize - 1;      // 页内行号（0起）

// 跳转到正确的页
this.myTable1.setState({ pageno, rowindex }, () => {
    setTimeout(() => {
        this.myTable1.loadTableData();  // 加载那一页数据
    });
});

// 原始数据（平级）：
[
    { id: 'A',  text: '饮料',     parentnodeid: '' },
    { id: 'A1', text: '非酒精饮料', parentnodeid: 'A' },
    { id: 'A2', text: '酒精饮料',  parentnodeid: 'A' },
    { id: 'B',  text: '食品',     parentnodeid: '' },
]

// toTreeData() 转换后（嵌套树形）：
[
    {
        id: 'A', text: '饮料',
        children: [
            { id: 'A1', text: '非酒精饮料', children: [] },
            { id: 'A2', text: '酒精饮料', children: [] },
        ]
    },
    { id: 'B', text: '食品', children: [] }
]

// toTreeData 核心逻辑（简化版）
const toTreeData = (data) => {
    let map = {};
    let result = [];

    // 第一步：建立 id → 节点对象的映射表，方便快速查找父节点
    data.forEach(item => { map[item.id] = item; });

    // 第二步：遍历，把每个节点挂到父节点的 children 里
    data.forEach(item => {
        let parent = map[item.parentnodeid];
        if (parent && parent.id !== '') {
            // 有父节点：挂到父节点的 children
            if (!parent.children) parent.children = [];
            parent.children.push(item);
        } else {
            // 没有父节点：作为根节点
            result.push(item);
        }
    });

    return result;
}

// 不确定对象是否存在时，用 ?. 避免报错
this.myTable1?.loadTableData();
// 等价于：
if (this.myTable1) this.myTable1.loadTableData();

// 访问可能为 null 的嵌套属性
let name = user?.profile?.name;  // user 或 profile 为 null 时返回 undefined，不报错

// 数组展开：合并数组
let arr = [...arr1, ...arr2];

// 对象展开：浅拷贝
let newState = { ...this.state };          // 复制状态
let newAttr = { ...this.myTable1.state.attr, categoryid: 'A1' }; // 更新某个字段

// 展开 props：把所有属性透传给子组件
<Tree {...this.props} />

// 函数可能不存在时，用 ?.() 避免报错
afterLoadData?.();
// 等价于：
if (typeof afterLoadData === 'function') afterLoadData();