class Heatbox {
    constructor(viewer, options)
    setData(entities)
    updateOptions(newOptions)
    setVisible(show)
    clear()
    destroy()
    getStatistics()
    getBounds()
    fitView(bounds, options)  // v0.1.9: Smart view assistance
}

const bounds = {
    minLon: number,     // Minimum longitude
    maxLon: number,     // Maximum longitude
    minLat: number,     // Minimum latitude
    maxLat: number,     // Maximum latitude
    minAlt: number,     // Minimum altitude
    maxAlt: number,     // Maximum altitude
    centerLon: number,  // Center longitude
    centerLat: number,  // Center latitude
    centerAlt: number   // Center altitude
};

const performanceLimits = {
    maxEntities: 5000,              // Maximum processable entities
    maxVoxels: 50000,              // Maximum renderable voxels
    maxEmptyVoxelsRendered: 10000,  // Empty voxel rendering limit
    minVoxelSize: 5,               // Minimum voxel size (meters)
    maxVoxelSize: 1000,            // Maximum voxel size (meters)
    warningThreshold: 30000,       // Warning display voxel count threshold
    // v0.1.9 Auto Render Budget device tiers
    deviceTiers: {
        low: { min: 8000, max: 12000 },
        mid: { min: 20000, max: 35000 },
        high: { min: 40000, max: 50000 }
    }
};

// No entities
if (entities.length === 0) {
    throw new Error('No target entities');
}

// Invalid position information
if (!position || isNaN(position.x)) {
    console.warn(`Entity ${index} has invalid position`);
    continue; // Skip and continue processing
}

// Voxel count exceeds limit
if (totalVoxels > maxVoxels) {
    throw new Error(
        `Voxel count exceeds limit(${maxVoxels}): ${totalVoxels}\n` +
        `Please increase voxel size to ${recommendedSize}m or higher`
    );
}

// モダンブラウザ・Node.js環境向け
import Heatbox from 'cesium-heatbox';
import { generateTestEntities } from 'cesium-heatbox';

// 古いNode.js環境
const Heatbox = require('cesium-heatbox');

// webpack.config.js
const path = require('path');
const ESLintPlugin = require('eslint-webpack-plugin');

module.exports = (env, argv) => {
  const isProduction = argv.mode === 'production';
  
  return {
    entry: './src/index.js',
    
    output: {
      path: path.resolve(__dirname, 'dist'),
      filename: isProduction ? 
        'cesium-heatbox.min.js' : 
        'cesium-heatbox.js',
      library: {
        name: 'CesiumHeatbox',
        type: 'umd',
        export: 'default'
      },
      globalObject: 'this',
      clean: true
    },
    
    externals: {
      cesium: {
        commonjs: 'cesium',
        commonjs2: 'cesium',
        amd: 'cesium',
        root: 'Cesium'
      }
    },
    
    module: {
      rules: [
        {
          test: /\.js$/,
          exclude: /node_modules/,
          use: {
            loader: 'babel-loader',
            options: {
              presets: [
                ['@babel/preset-env', {
                  targets: {
                    browsers: ["> 1%", "last 2 versions", "not dead"]
                  }
                }]
              ]
            }
          }
        }
      ]
    },
    
    plugins: [
      new ESLintPlugin({
        extensions: ['js'],
        configType: 'eslintrc',
        fix: true
      })
    ],
    
    resolve: {
      extensions: ['.js']
    },
    
    devtool: isProduction ? 'source-map' : 'eval-source-map',
    
    optimization: {
      minimize: isProduction
    },
    
    devServer: {
      static: {
        directory: path.join(__dirname, 'examples'),
      },
      compress: true,
      port: 8080,
      hot: true,
      open: true
    }
  };
};

// eslint.config.js (ESLint 9.0+対応)
import js from '@eslint/js';
import typescript from '@typescript-eslint/eslint-plugin';
import typescriptParser from '@typescript-eslint/parser';
import jest from 'eslint-plugin-jest';

export default [
  js.configs.recommended,
  {
    files: ['src/**/*.js'],
    languageOptions: {
      ecmaVersion: 2022,
      sourceType: 'module',
      globals: {
        Cesium: 'readonly'
      }
    },
    rules: {
      'no-console': 'warn',
      'prefer-const': 'error',
      'no-var': 'error'
    }
  },
  {
    files: ['src/**/*.ts'],
    languageOptions: {
      parser: typescriptParser,
      parserOptions: {
        ecmaVersion: 2022,
        sourceType: 'module'
      }
    },
    plugins: {
      '@typescript-eslint': typescript
    },
    rules: {
      ...typescript.configs.recommended.rules
    }
  },
  {
    files: ['test/**/*.js', 'test/**/*.ts'],
    ...jest.configs['flat/recommended'],
    rules: {
      ...jest.configs['flat/recommended'].rules,
      'jest/prefer-expect-assertions': 'off'
    }
  }
];

// jest.config.js
export default {
  testEnvironment: 'jsdom',
  setupFilesAfterEnv: ['<rootDir>/test/setup.js'],
  moduleNameMapping: {
    '^@/(.*)': '<rootDir>/src/$1'
  },
  collectCoverageFrom: [
    'src/**/*.{js,ts}',
    '!src/index.{js,ts}'
  ],
  coverageDirectory: 'coverage',
  coverageReporters: ['text', 'lcov', 'html'],
  transform: {
    '^.+\.(js|ts)': 'babel-jest'
  },
  testMatch: [
    '<rootDir>/test/**/*.{test,spec}.{js,ts}'
  ]
};

// 度からメートルへの概算変換
const lonRangeMeters = (maxLon - minLon) * 111000 * Math.cos(centerLat_rad);
const latRangeMeters = (maxLat - minLat) * 111000;

// ボクセルインデックス計算
const voxelX = Math.floor(
    (lon - bounds.minLon) / (bounds.maxLon - bounds.minLon) * grid.numVoxelsX
);
const voxelY = Math.floor(
    (lat - bounds.minLat) / (bounds.maxLat - bounds.minLat) * grid.numVoxelsY
);
const voxelZ = Math.floor(
    (alt - bounds.minAlt) / (bounds.maxAlt - bounds.minAlt) * grid.numVoxelsZ
);

class VoxelRenderer {
  createBatchedVoxels(voxelData, options) {
    const instances = [];
    const { minCount, maxCount } = this.statistics;
    
    voxelData.forEach((voxel) => {
      // HSV補間による色計算
      const normalizedDensity = (voxel.count - minCount) / (maxCount - minCount);
      const hue = (1.0 - normalizedDensity) * 240; // 青(240°) → 赤(0°)
      const saturation = 0.8 + normalizedDensity * 0.2; // 彩度調整
      const brightness = 0.7 + normalizedDensity * 0.3; // 明度調整
      
      const color = Cesium.Color.fromHsl(hue / 360, saturation, brightness);
      
      // GeometryInstance作成
      const instance = new Cesium.GeometryInstance({
        geometry: new Cesium.BoxGeometry({
          vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
          dimensions: new Cesium.Cartesian3(
            grid.cellSizeX,
            grid.cellSizeY,
            grid.cellSizeZ
          )
        }),
        modelMatrix: Cesium.Matrix4.multiplyByTranslation(
          Cesium.Transforms.eastNorthUpToFixedFrame(voxel.worldPosition),
          new Cesium.Cartesian3(0, 0, grid.cellSizeZ / 2),
          new Cesium.Matrix4()
        ),
        attributes: {
          color: Cesium.ColorGeometryInstanceAttribute.fromColor(
            color.withAlpha(this.options.opacity)
          )
        }
      });
      
      instances.push(instance);
    });
    
    // Primitive作成（バッチ描画）
    const primitive = new Cesium.Primitive({
      geometryInstances: instances,
      appearance: new Cesium.PerInstanceColorAppearance({
        closed: true,
        translucent: this.options.opacity < 1.0
      }),
      allowPicking: true
    });
    
    return primitive;
  }
}

class Heatbox {
    constructor(viewer, options)
    setData(entities)
    updateOptions(newOptions)
    setVisible(show)
    clear()
    destroy()
    getStatistics()
    getBounds()
    fitView(bounds, options)  // v0.1.9: スマート視覚化支援
}

const bounds = {
    minLon: number,     // 最小経度
    maxLon: number,     // 最大経度
    minLat: number,     // 最小緯度
    maxLat: number,     // 最大緯度
    minAlt: number,     // 最小高度
    maxAlt: number,     // 最大高度
    centerLon: number,  // 中心経度
    centerLat: number,  // 中心緯度
    centerAlt: number   // 中心高度
};

const grid = {
    numVoxelsX: number,        // X方向ボクセル数
    numVoxelsY: number,        // Y方向ボクセル数
    numVoxelsZ: number,        // Z方向ボクセル数
    totalVoxels: number,       // 総ボクセル数
    voxelSizeMeters: number,   // ボクセルサイズ（メートル）
    lonRangeMeters: number,    // 経度範囲（メートル）
    latRangeMeters: number,    // 緯度範囲（メートル）
    altRangeMeters: number     // 高度範囲（メートル）
};

const voxelData = new Map(); // Key: "x,y,z", Value: VoxelInfo

const voxelInfo = {
    x: number,              // ボクセルX座標
    y: number,              // ボクセルY座標  
    z: number,              // ボクセルZ座標
    entities: Entity[],     // 含まれるエンティティ配列
    count: number          // エンティティ数
};

new Heatbox(viewer, options)

const options = {
    voxelSize: 20,                    // 目標ボクセルサイズ（メートル）（実寸は cellSizeX/Y/Z）
    opacity: 0.8,                     // データボクセルの透明度
    emptyOpacity: 0.03,               // 空ボクセルの透明度
    showOutline: true,                // アウトライン表示
    showEmptyVoxels: false,           // 空ボクセル表示
    minColor: [0, 32, 255],          // 最小密度の色（RGB）
    maxColor: [255, 64, 0],          // 最大密度の色（RGB）
    maxRenderVoxels: 50000,          // 最大描画ボクセル数
    batchMode: 'auto'                // 'auto' | 'primitive' | 'entity'
};

heatbox.setData(entities);

heatbox.updateOptions({ voxelSize: 30 });

// 表示/非表示切り替え
heatbox.setVisible(true/false);

// 統計情報取得
const stats = heatbox.getStatistics();

// 境界情報取得
const bounds = heatbox.getBounds();

// 全クリア
heatbox.clear();

// インスタンス破棄
heatbox.destroy();

// Heatboxインスタンスを生成するヘルパー関数
const heatbox = createHeatbox(viewer, options);

// 全エンティティ取得
const allEntities = getAllEntities(viewer);

// テスト用エンティティ生成
const testEntities = generateTestEntities(viewer, bounds, count);

// 環境情報取得
const envInfo = getEnvironmentInfo();

const performanceLimits = {
    maxEntities: 5000,              // 処理可能な最大エンティティ数
    maxVoxels: 50000,              // 描画可能な最大ボクセル数
    maxEmptyVoxelsRendered: 10000,  // 空ボクセル描画上限
    minVoxelSize: 5,               // 最小ボクセルサイズ（メートル）
    maxVoxelSize: 1000,            // 最大ボクセルサイズ（メートル）
    warningThreshold: 30000,       // 警告表示のボクセル数閾値
    // v0.1.9 自動レンダリング予算の端末ティア
    deviceTiers: {
        low: { min: 8000, max: 12000 },    // 低性能端末
        mid: { min: 20000, max: 35000 },   // 中性能端末
        high: { min: 40000, max: 50000 }   // 高性能端末
    }
};

// エンティティなし
if (entities.length === 0) {
    throw new Error('対象エンティティがありません');
}

// 無効な位置情報
if (!position || isNaN(position.x)) {
    console.warn(`エンティティ ${index} の位置が無効です`);
    continue; // スキップして処理継続
}

// ボクセル数上限超過
if (totalVoxels > maxVoxels) {
    throw new Error(
        `ボクセル数が上限(${maxVoxels})を超えています: ${totalVoxels}個\n` +
        `ボクセルサイズを${recommendedSize}m以上に増やしてください`
    );
}

// メモリ不足警告
if (estimatedMemory > warningThreshold) {
    console.warn(
        `推定メモリ使用量: ${estimatedMemory}MB\n` +
        `パフォーマンスが低下する可能性があります`
    );
}

// Viewer未初期化
if (!this.viewer) {
    throw new Error('CesiumJS Viewerが初期化されていません');
}

// WebGL対応チェック
if (!viewer.scene.canvas.getContext('webgl')) {
    throw new Error('WebGLがサポートされていません');
}

const defaultSettings = {
    voxelSize: 20,              // 東京駅規模に最適
    entityCount: 800,           // バランスの良い数
    opacity: 0.8,               // データボクセル
    emptyOpacity: 0.03,         // 空ボクセル
    showOutline: true,          // 境界線表示
    showEmptyVoxels: false      // 空ボクセル非表示
};

const controlRanges = {
    voxelSize: { 
        min: 10, max: 100, step: 5,
        sliderRange: [10, 50]    // UIスライダーの推奨範囲
    },
    entityCount: { 
        min: 50, max: 3000, step: 50,
        recommended: [200, 1500]  // 推奨範囲
    },
    opacity: { 
        min: 0.1, max: 1.0, step: 0.1,
        dataVoxel: [0.5, 1.0],   // データボクセル推奨
        emptyVoxel: [0.01, 0.2]  // 空ボクセル推奨
    }
};

const statisticsUI = {
    format: `
        総ボクセル数: ${stats.totalVoxels.toLocaleString()}
        表示ボクセル数: ${stats.renderedVoxels.toLocaleString()}
        非空ボクセル数: ${stats.nonEmptyVoxels.toLocaleString()}
        総エンティティ数: ${stats.totalEntities.toLocaleString()}
        最小密度: ${stats.minCount}
        最大密度: ${stats.maxCount}
        平均密度: ${stats.averageCount.toFixed(2)}
    `,
    updateTiming: "リアルタイム更新"
};

describe('Heatbox', () => {
    // 正常系テスト
    test('基本的なヒートマップ作成', () => {});
    test('異なるボクセルサイズでの動作', () => {});
    test('空ボクセル表示の切り替え', () => {});
    
    // 異常系テスト
    test('エンティティなしでのエラー処理', () => {});
    test('無効な位置情報の処理', () => {});
    test('メモリ上限超過時の処理', () => {});
});

// vitest.bench.config.js
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    benchmark: {
      include: ['test/benchmark/**/*.bench.{js,ts}'],
      outputFile: './benchmark-results.csv',
      reporters: ['verbose', 'csv']
    }
  }
});

// test/e2e/extreme-cases.test.js
describe('極値ケーステスト', () => {
  test('100mボクセル×500m範囲での性能', async () => {
    const bounds = { /* 500m × 500m range */ };
    const options = { voxelSize: 100 };
    const entities = generateTestEntities(viewer, bounds, 1000);
    
    const startTime = performance.now();
    await heatmap.createFromEntities(entities);
    const endTime = performance.now();
    
    expect(endTime - startTime).toBeLessThan(3000); // 3秒以内
    expect(heatmap.getStatistics().renderedVoxels).toBeLessThan(125); // 5×5×5
  });
});

module.exports = {
    extends: ['standard'],
    rules: {
        'no-console': 'warn',
        'prefer-const': 'error',
        'no-var': 'error'
    },
    globals: {
        Cesium: 'readonly'
    }
};

/**
 * エンティティからヒートマップを作成
 * @param {Array<Cesium.Entity>} entities - 対象エンティティ配列
 * @returns {Promise<Object>} 統計情報
 * @throws {Error} エンティティが空の場合
 * @example
 * const stats = await heatbox.createFromEntities(entities);
 */

// 3D空間の均等分割
const voxelIndex = {
    x: Math.floor((position.x - minX) / voxelSize),
    y: Math.floor((position.y - minY) / voxelSize), 
    z: Math.floor((position.z - minZ) / voxelSize)
};

const scaleConstraints = {
    minimumArea: "10m × 10m",      // 最小解析範囲
    maximumArea: "10km × 10km",    // 最大解析範囲
    recommendedArea: "100m-1km",    // 推奨範囲
    heightRange: "0-1000m"         // 推奨高度範囲
};

const buildingLevelConfig = {
    voxelSize: 10,
    area: "100m × 100m",
    entities: 500,
    useCase: "建物内人流解析"
};

const blockLevelConfig = {
    voxelSize: 25,
    area: "500m × 500m", 
    entities: 1500,
    useCase: "商業地区分析"
};

const districtLevelConfig = {
    voxelSize: 50,
    area: "1km × 1km",
    entities: 3000,
    useCase: "都市計画支援"
};