Dashboards

// Dashboard configuration
const dashboardConfig = {
  // Dashboard types
  types: {
    operational: {
      refreshRate: 60, // seconds
      timeRanges: ['1h', '6h', '24h', '7d'],
      defaultTimeRange: '24h'
    },
    analytical: {
      refreshRate: 3600, // seconds
      timeRanges: ['7d', '30d', '90d', '1y'],
      defaultTimeRange: '30d'
    },
    strategic: {
      refreshRate: 86400, // seconds
      timeRanges: ['30d', '90d', '1y', 'ytd'],
      defaultTimeRange: '90d'
    }
  },

  // Dashboard layout
  layout: {
    grid: {
      columns: 12,
      rowHeight: 80,
      margin: 10,
      containerPadding: 20
    },
    
    // Panel sizes
    panelSizes: {
      small: { w: 3, h: 2 },
      medium: { w: 6, h: 3 },
      large: { w: 9, h: 4 },
      full: { w: 12, h: 6 }
    }
  },

  // Create dashboard configuration
  createDashboard(name, type, description) {
    return {
      id: this.generateId(),
      name,
      type,
      description,
      timeRange: this.types[type].defaultTimeRange,
      refreshRate: this.types[type].refreshRate,
      panels: [],
      layout: this.layout,
      created: new Date(),
      updated: new Date()
    };
  }
}

// Data source configuration
const dataSources = {
  // Source types
  types: {
    prometheus: {
      type: 'time-series',
      connection: {
        url: 'http://prometheus:9090',
        auth: 'token'
      },
      queryLanguage: 'PromQL'
    },
    elasticsearch: {
      type: 'document',
      connection: {
        url: 'http://elasticsearch:9200',
        auth: 'basic'
      },
      queryLanguage: 'Lucene'
    },
    postgres: {
      type: 'sql',
      connection: {
        host: 'postgres',
        port: 5432,
        auth: 'user-pass'
      },
      queryLanguage: 'SQL'
    },
    rest: {
      type: 'api',
      connection: {
        baseUrl: 'https://api.example.com',
        auth: 'oauth2'
      },
      queryLanguage: 'JSON'
    }
  },

  // Register a data source
  async registerDataSource(name, type, config) {
    const sourceType = this.types[type];
    
    if (!sourceType) {
      throw new Error(`Unknown data source type: ${type}`);
    }
    
    const dataSource = {
      id: this.generateId(),
      name,
      type,
      config: {
        ...sourceType.connection,
        ...config
      },
      status: 'pending',
      created: new Date()
    };
    
    // Test connection
    const connectionStatus = await this.testConnection(dataSource);
    dataSource.status = connectionStatus.success ? 'active' : 'error';
    dataSource.lastError = connectionStatus.error;
    
    await this.saveDataSource(dataSource);
    return dataSource;
  },

  // Query data source
  async queryDataSource(sourceId, query, options = {}) {
    const source = await this.getDataSource(sourceId);
    
    if (!source || source.status !== 'active') {
      throw new Error(`Data source ${sourceId} is not available`);
    }
    
    const queryRunner = this.getQueryRunner(source.type);
    return await queryRunner.execute(source, query, options);
  }
}

// Panel configuration
const panelBuilder = {
  // Panel types
  types: {
    timeSeries: {
      dataTypes: ['time-series'],
      options: {
        lineWidth: 1,
        fillOpacity: 0.1,
        showPoints: 'auto',
        stacking: { mode: 'none' },
        legend: { placement: 'bottom' }
      }
    },
    gauge: {
      dataTypes: ['single-value'],
      options: {
        minValue: 0,
        maxValue: 100,
        thresholds: [
          { value: 30, color: 'green' },
          { value: 60, color: 'orange' },
          { value: 90, color: 'red' }
        ]
      }
    },
    stat: {
      dataTypes: ['single-value'],
      options: {
        textMode: 'value',
        colorMode: 'value',
        graphMode: 'area',
        reduceOptions: { calcs: ['lastNotNull'] }
      }
    },
    table: {
      dataTypes: ['table', 'time-series'],
      options: {
        showHeader: true,
        footer: { show: false },
        pagination: { show: true, pageSize: 10 }
      }
    },
    pieChart: {
      dataTypes: ['table'],
      options: {
        legendType: 'list',
        legendPlacement: 'right',
        tooltipMode: 'single'
      }
    }
  },

  // Create panel
  createPanel(title, type, dataSource, query) {
    if (!this.types[type]) {
      throw new Error(`Unknown panel type: ${type}`);
    }
    
    return {
      id: this.generateId(),
      title,
      type,
      dataSource,
      query,
      options: { ...this.types[type].options },
      gridPos: { ...dashboardConfig.layout.panelSizes.medium },
      created: new Date(),
      updated: new Date()
    };
  },

  // Update panel options
  updatePanelOptions(panel, options) {
    return {
      ...panel,
      options: {
        ...panel.options,
        ...options
      },
      updated: new Date()
    };
  }
}

// Dashboard interactivity
const dashboardInteractivity = {
  // Variable types
  variableTypes: {
    query: {
      name: 'Query variable',
      description: 'Variable values are fetched from a data source query'
    },
    custom: {
      name: 'Custom variable',
      description: 'Variable values are defined manually'
    },
    textbox: {
      name: 'Text box',
      description: 'Free text input field'
    },
    constant: {
      name: 'Constant',
      description: 'Define a hidden constant variable'
    },
    datasource: {
      name: 'Data source',
      description: 'Select a data source'
    }
  },

  // Create dashboard variable
  createVariable(dashboard, config) {
    const variable = {
      id: this.generateId(),
      name: config.name,
      type: config.type,
      label: config.label || config.name,
      description: config.description || '',
      options: config.options || [],
      current: config.current || null,
      query: config.query || null,
      datasource: config.datasource || null,
      refresh: config.refresh || 0,
      hide: config.hide || false,
      multi: config.multi || false,
      includeAll: config.includeAll || false
    };
    
    dashboard.variables = dashboard.variables || [];
    dashboard.variables.push(variable);
    
    return dashboard;
  },

  // Add time range selector
  addTimeRangeSelector(dashboard, options = {}) {
    dashboard.timeOptions = {
      now: true,
      refresh: options.refresh || '1m',
      timeZone: options.timeZone || 'browser',
      ranges: options.ranges || dashboardConfig.types[dashboard.type].timeRanges
    };
    
    return dashboard;
  },

  // Add dashboard filters
  addFilters(dashboard, filters) {
    dashboard.filters = filters.map(filter => ({
      id: this.generateId(),
      name: filter.name,
      label: filter.label || filter.name,
      type: filter.type || 'string',
      datasource: filter.datasource,
      query: filter.query,
      options: filter.options || [],
      current: filter.current || null,
      multi: filter.multi || false
    }));
    
    return dashboard;
  }
}