export declare class CommonService {
    getBaseServerUrl()
    setBaseServerUrl(url)
}

import {commonService} from 'cboard-common';

commonService.setBaseServerUrl('http://localhost:8026/cboard');

export declare class loginService {
    isSDK: Boolean
    getTokenInfo(key)
    getToken()
    getUserName()
    getUserId()
    auth(username, password)
    authDigest(username, password)
    authByJwtToken(token)
    authByShareId(shareId)
}

import { loginService } from 'cboard-common';

loginService.isSDK = true;
loginService.auth('admin', 'root123').then(res => {
    console.log(res)
    const {valid, token} = res.data;
    if (valid) {
       console.log(res)
       this.token = token;
    }
});

public class AuthResult {
  boolean valid;
  String token;
  User user;
  String msg;
}

export class Widget {
  constructor(args) {
    let {name} = args || {};
    Object.assign(this, {
      name,
      data: {
        datasetId: null,
        datasource: null,
        query: {
          _sid: randomId(),
        },
        config: {
          chart_type: 'table',
          selects: [],
          keys: [],
          groups: [],
          values: [
            {series_type: null, name: '', cols: []}
          ],
          filters: [],
          option: {},
          calColumns: [],// 图表级计算字段
        },
        expressions: [], // 图表级表达式
        filterGroups: [], // 图表级过滤组合
        variables: [], // 图表级变量
      }
    });
  }
}

import { Widget } from 'cboard-common';
new Widget();

class WidgetConfig {
  // 数据源查询配置
  datasetId: null;
  datasource: null;
  query: { _sid: randomId, };
  // 多维查询配置/图表配置
  config: ChartConfig
  // 图表级表达式
  expressions: [];
  // 图表级过滤组合
  filterGroups: [];
  // 图表级变量
  variables: []; 
}

class ChartConfig {
  String chart_type;
  List<Dim> keys;
  List<Dim> groups;
  List<Dim> filters;
  List<Value> values;
  Object option = new Object();
  calColumns: [];// 图表级计算字段
}

// 维度
class Dim {
  //String sid; // 在DSL中唯一id
  //如果需要使用层级下钻功能，id必须与维度层级下面的维度相对应
  String id; // 数据集节点id
  String rawDataType; // 原始数据类型
  String alias; // 字段别名
  @required
  String column; // 字段
  String dateFormat; // 日期字段格式化, 与Java中日期格式化对应
  FilterType type; // 过滤类型  3.1中 <filterType> 类型
  List<Object> values; // 比较值 参照3.1 过滤之数组 <filterValues>
  String sort = "asc"; // 维度值排序 ['asc', 'desc']
}

// 指标栏
class Value {
  String sort = "asc"; // 维度值排序 ['asc', 'desc']
  // 双轴图: 'line', 'arealine', 'stackline', 'percentline', 'bar', 'stackbar', 'percentbar'; 
  // 饼图: 'pie', 'coxcomb', 'doughnut'
  String series_type; 
  List<Metric> cols; // 指标列
}

// 与SQL中的聚合函数类似 `aggregate_type(col)`
class Metric  {
  String sid; // 在DSL中唯一id
  String id; // 数据集节点id
  String alias; // 数据集节点.a 可以修改为新的名称
  AggType aggregate_type; // 汇总类型, 聚合函数
  @required
  String col; // 数据集节点.column
  String f_type; // 过滤类型 枚举 只能选择3.1中 <filterType> 类型
  ValueType valueType; // 值显示方式
  List<Object> f_values;
  @required
  String type; // 数据集节点.t
  String exp; // 非必须, String, 汇总表达式, measure 的 exp 属性
}

/**
- <filterValues>: 过滤值数组，与<filterType>组合形成过滤条件，数组中多余的值会被忽略，如
- <dateFormat>: String, 日期格式化, 当 字段 为 'date' 类型时，可以对字段进行格式化 Pattern列表:
  - yyyy,年,2025
  - Q,季度, 1-4
  - MM,月,01-12
  - dd,日,01-31
**/
enum FilterType {
  // 等值与不等值 相当于sql中的`in`与`not in`
  '=', '≠'
  // 开区间
  '≥', '≤',
  // 闭区间
  '[a,b]', // 相当于sql中的between
  'like', 'not like'
}

enum AggType {
  sum, min, max, avg, distinct
}

enum ValueType {
  value, //原始值
  percentByColumn, // 列占比, 行维度方向上计算占比
  percentByRow, // 行占比, 列维度方向上计算占比
  percentByTotal, // 总占比
  row_number, // 序号
  cum_cum, // 累加
  cum_sum_% // 累加占比
}

export declare class DataService {
    newWidgetConfig()
    // @ts-ignore
    linkDataset(args)
    replaceWgtCfgVariable(widgetConfig)
    // 环境变量设置
    setEnvVariables(variables: Object, clean: boolean)
    getVariables(chartConfig)
    // 获取维度成员信息
    getDimMembers(args)
    getColumnStat(args)
    // @ts-ignore
    directQuery(datasourceId, query, opt)
    queryForList(args)
    getDetailData(args)
    downloadDetailData(args)

    queryDefer(chartConfig)
    queryAggData(args)
    queryBasicAggData(args)
  
    getDataSeries(widgetConfig)
    viewQuery(args)
  
    getColumns(args)
    getColumnsByWidgetId(widgetId)
  
    castRawData2Series(aggData, chartConfig, sortCfg)
  
    getAllDimensions(datasetId, datasourceId, query)
}

dataService.replaceWgtCfgVariable({
  // 省略其他属性
  keys: [{
    column: 'month',
    type: '=',
    values: ['${cdt.now(), "yyyy-MM-dd"}']
  }]
}).then(res => {
  
});

res = { column: 'month', type: '=', values: ['2025-04-02'] }

// 设置环境变量
dataService.setEnvVariables({foo: 'bar', key: 1, dateRange: ['2025-01-01', '2025-04-05']});

/** 获取环境变量
 * @param vars 赋值优先级最高变量
 * @param objectResult 是否以对象形式返回，默认返回字符串
 * @returns {{}|string}
 */
function getVariables(vars, objectResult = false) {  }

// 设置环境变量
dataService.setEnvVariables({foo: 'bar', key: 1, dateRange: ['2025-01-01', '2025-04-05']});
// 返回对象 {foo: 'bar', key: 3, dateRange: ['2025-01-01', '2025-04-05']}
dataService.getVariables({key: 3}, true);
// 返回对象字符串 "{foo: 'bar', key: 2, dateRange: ['2025-01-01', '2025-04-05']}"
dataService.getVariables({key: 2});

dataService.getDataSeries({
  widgetConfig: {
    datasetId: 1,
    // chartConfig
    config: {
      chart_type: 'table',
      keys: [{
        column: 'the_year',
      }],
      groups: [{
        column: 'sales_country'
      }],
      filters: [],
      values: [{
        cols: [{
          aggregate_type: 'sum',
          col: 'store_sales',
        }]
      }],
      option: {},
    }
  }
}).then(seriresData => {
  this.jsonData = seriresData;
}).catch(e => {
  this.jsonData = e;
})

{
  "keys": [...],
  "groups": [...],
  "metrics": [...],
  "series": [...],
  "data": [...],
  "seriesConfig": {...},
  "chartConfig": {...},
  "pivotModel": {...},
  "keyInfos": [...],
  "groupInfos": [...],
  "aggData": {...},
  "drill": {...}
}

{
   [系列名]: {
      seriesName: '',
      seriesIdx: 0,
      data: [], // 系列数据
      valueConfig: {}, // 指标配置
      groupInfos: [], // 列维信息数组
   },
   ...
}

dataService.viewQuery({
  widgetConfig
}).then(res => {
  // res为查询脚本数组
  // ['sql1', 'sql2']
})

dataService.getDetailData({
    widgetConfig,
    resultLimit, // 查询结果集大小限制，默认: 2000
}).then(res => {
    
}).catch(e => {
  // 异常处理
})

{
  data: {
    columnList: [{}, ...], // 字段对象
    data: [["United States of America", "F", 2021, "#NULL"], ...], // 二维数据
    count: 55264, // 总记录数
    detail: true,
  },
  chartConfig: {...},
}

dataService.getDimMembers({
  datasetId: 1,
  dimCfg: { column: 'sales_country' }, // dimCfg可以是对象或者字段字符串
  // dimCfg:'sales_country', 
  keywords: 'a' // 关键词限定，模糊查询值中包含字母a的成员
}).then(res => {
  // 返回 [{value: 'Canada'}, {value: 'Mexico'}]
})

dataService.getDimMembers({
  datasetId: 1,
  dimCfg: { column: 'sales_region' }, // dimCfg可以是对象或者字段字符串
  chartConfig: {
    keys: [{
      id: '8clz4jnwc',
      column: 'sales_country',
      type: '=',
      values: ['Canada']
    }],
  }
}).then(res => {
  // 当前返回值为Ajax原始的Response对象，后续版本迭代可能会做解构操作
});

dataService.getColumnStat({
  datasetId: 1,
  dimCfg: { column: 'store_sales' }, // dimCfg可以是对象或者字段字符串
}).then(res => {
  this.jsonData = res.data;
})

{
  "min": 0.5,
  "max": 49.99,
  "avg": 8.31538858,
  "count": 55265
}

dataService.directQuery(1,
  'select * from department',
  {
    resultLimit: 5, 
    variables: {foo: 'bar'}, // 环境变量
  }
).then(res => {
  res.data;
});

{
  "data": [
    [ 1, "HQ General Management" ],
    [ 2, "HQ Information Systems" ],
    ...
  ],
  "columns": [
    {
      "columnName": "DEPARTMENT_ID",
      "remarks": null,
      "dataType": null,
      "typeCategory": null,
      "innerTypeName": null,
      "type": "INT",
      "ordinalPosition": null
    },
    {
      "columnName": "DEPARTMENT_DESCRIPTION",
      "remarks": null,
      "dataType": null,
      "typeCategory": null,
      "innerTypeName": null,
      "type": "STRING",
      "ordinalPosition": null
    }
  ],
}

export declare class AdminService {
    changePwd(user)
    getUserDetails()
    getUserList()
    getUserRoleList()
    getRoleList()
    getRoleResList()
    grantUserRoles(userIds, roleIds)
    revokeRoleOfUser(userIds, roleIds)
    shareResources(roleIds, resIds)
    updateRoleRes(roleIds, resIds)
    grantRoleRes(roleIds, resources)
    revokeRoleRes(roleIds, resources)
    updateUserRes(userIds, resIds)
    grantUserRes(userIds, resIds)
    revokeUserRes(userIds, resIds)
    getAllUserResList()
    newUser(user)
    updateUser(user)
    deleteUser(userId)
    newRole(role)
    updateRole(role)
    deleteRole(roleId)
    isAdmin()
    getJobList()
    handoverAcl(srcUserId, toUserId)
    getResUserList(resType, resId)
}

export declare class DatasourceService {
    getById(id)
    getDatasourceList(lite = true, specFolderId?)
    getDatasourceTreeData(specFolderId?)
    new(datasource)
    update(datasource)
    delete(id)
    getDatasourceParams(dpType)
    getQueryParams(sourceType, pageType)
    testQuery(datasource, queryObj)
    listDatabases(datasourceId)
    listSchemas(datasourceId, databaseName)
    listTables(datasourceId, databaseName, schemaName)
    listColumns(datasourceId, databaseName, schemaName, tableName)
}

export declare class DatasetService {
    getById(datasetId)
    getByIds(ids)
    getDatasetList(specFolderId?)
    getDatasetTreeData(specFolderId?)
    getDatasetListByDsr(datasourceId)
    new(dataset)
    update(dataset)
    delete(datasetId)
    getDimByIdFromDataset(nodeId, dataset)
    testTemplateRuleMatch(input, regex)
}

export declare class WidgetService {
    getById(widgetId)
    getWidgetList(specFolderId?)
    getWidgetListByDsr(datasourceId)
    getWidgetListByDst(datasetId)
    getWidgetTreeData(datasetList, datasourceList, specFolderId?)
    new(widget)
    update(widget)
    delete(widgetId)
    checkWidget(widgetId)
    compileChartConfig(chartConfig)
}

export declare class BoardService {
    getBoardData(boardId)
    getBoardList(specFolderId)
    getBoardTreeData(layoutType, specFolderId)
    getBoardNestLoopTreeData2(layoutType, specFolderId)
    new(board)
    update(board)
    delete(boardId)
    cacheParams(boardId, filters)
    getCachedParams(key)
}

import { chartService } from 'chart-services'

this.drawChart(containerDom, widgetConfig, options = {}) { ... }

this.chartDom = this.$el.querySelector('.view-div');
try {
  chartService.drawChart($(this.chartDom), {
    widgetName: '去年的总销售额',
    datasetId: 240820113813950,
    config: {
      chart_type: 'line',
      keys: [
        {
          column: '订单日期',
          dateFormat: 'yyyy',
        }
      ],
      groups: [],
      filters: [],
      values: [{
        cols: [
          {
            sid: 'v1',
            // id: 'qjjm6fjtuq',
            col: '销售额',
            aggregate_type: 'sum'
          }
        ]
      }],
      option: {
        title: {
          show: true,
        },
        drillConfig: {
          allow: true,
          freeMode: true,
        },
        devTool: {
          beforeRender(option) {
            console.log(JSON.stringify(option));
            _.merge(option, {
              title: {
                text: '名称改变',
              },
            })
          },
        }
      }
    }
  }).then(response => {
    let {
      //updater,
      render
    } = response;
    this.render = render;
  })
} catch (e) {
  console.log(e)
}