// httpServer.js - HTTP 接口服务
const http = require('http');
const url = require('url');
const logger = require('./logger');
const dataCache = require('./dataCache');
const rateLimiter = require('./rateLimiter');
const propertyMapper = require('./propertyMapper');

class HttpServer {
    constructor(port = 8080, config = {}) {
        this.port = port;
        this.config = {
            enabled: config.enabled !== false,
            host: config.host || '0.0.0.0',
            cors: {
                enabled: config.cors?.enabled !== false,
                allowOrigin: config.cors?.allowOrigin || '*'
            },
            rateLimit: {
                enabled: config.rateLimit?.enabled !== false,
                interval: config.rateLimit?.interval || 5000, // 默认 5 秒
                allDevicesInterval: config.rateLimit?.allDevicesInterval || 60000 // 默认 1 分钟
            },
            propertyMapping: {
                enabled: config.propertyMapping?.enabled !== false,
                includeRawData: config.propertyMapping?.includeRawData === true
            }
        };
        this.server = null;
    }

    /**
     * 启动 HTTP 服务
     */
    start() {
        if (!this.config.enabled) {
            logger.info('🔴 HTTP 服务已禁用');
            return;
        }

        this.server = http.createServer((req, res) => {
            this.handleRequest(req, res);
        });

        this.server.on('error', (err) => {
            logger.error(`HTTP 服务错误: ${err.message}`);
        });

        this.server.listen(this.port, this.config.host, () => {
            logger.info(`🌐 HTTP 服务已启动，监听地址: ${this.config.host}:${this.port}`);
        });
    }

    /**
     * 处理 HTTP 请求
     */
    handleRequest(req, res) {
        const parsedUrl = url.parse(req.url, true);
        const pathname = parsedUrl.pathname;
        const query = parsedUrl.query;

        // 设置通用响应头
        res.setHeader('Content-Type', 'application/json; charset=utf-8');
        
        // 根据配置设置 CORS 头
        if (this.config.cors.enabled) {
            res.setHeader('Access-Control-Allow-Origin', this.config.cors.allowOrigin);
            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
        }

        // 处理 OPTIONS 请求（CORS 预检）
        if (req.method === 'OPTIONS') {
            res.writeHead(200);
            res.end();
            return;
        }

        try {
            logger.info(`📥 收到请求: ${req.method} ${pathname}${req.url.includes('?') ? '?' + req.url.split('?')[1] : ''}`);

            switch (pathname) {
                // 获取指定设备的最新数据
                case '/api/device/data':
                    this.handleGetDeviceData(req, res, query);
                    break;

                // 获取所有设备的数据
                case '/api/device/all':
                    this.handleGetAllDevices(req, res, query);
                    break;

                // 获取设备列表
                case '/api/device/list':
                    this.handleGetDeviceList(req, res);
                    break;

                // 获取缓存统计信息
                case '/api/cache/stats':
                    this.handleGetStats(req, res);
                    break;

                // 清空缓存
                case '/api/cache/clear':
                    this.handleClearCache(req, res);
                    break;

                // 获取限流统计信息
                case '/api/ratelimit/stats':
                    this.handleRateLimitStats(req, res);
                    break;

                // 清空限流记录
                case '/api/ratelimit/clear':
                    this.handleRateLimitClear(req, res);
                    break;

                // 获取空闲设备列表
                case '/api/device/idle':
                    this.handleGetIdleDevices(req, res, query);
                    break;

                // 健康检查
                case '/api/health':
                    this.handleHealth(req, res);
                    break;

                // 根路径
                case '/':
                    this.handleRoot(req, res);
                    break;

                default:
                    this.sendError(res, 404, '接口不存在');
            }
        } catch (err) {
            logger.error(`请求处理错误: ${err.message}`);
            this.sendError(res, 500, '服务器内部错误');
        }
    }

    /**
     * 获取指定设备的最新数据
     * GET /api/device/data?deviceNumber=D001
     * GET /api/device/data?deviceNumber=D001&mapped=true  (启用属性映射)
     */
    handleGetDeviceData(req, res, query) {
        const deviceNumber = query.deviceNumber;
        const enableMapping = query.mapped === 'true'; // 支持查询参数控制映射

        if (!deviceNumber) {
            this.sendError(res, 400, '缺少必要参数: deviceNumber');
            return;
        }

        // ✅【新增】限流检查 - 根据设备号进行限流
        if (this.config.rateLimit.enabled) {
            const limitCheck = rateLimiter.checkLimit(deviceNumber, this.config.rateLimit.interval);
            if (!limitCheck.allowed) {
                this.sendError(res, 429, `请求过于频繁，请在 ${limitCheck.remainingTime}ms 后再试`);
                return;
            }
        }

        const data = dataCache.getDeviceData(deviceNumber);

        if (!data) {
            this.sendError(res, 404, `设备 ${deviceNumber} 未找到`);
            return;
        }

        // ✅【新增】属性映射处理
        let responseData = {
            deviceNumber: deviceNumber,
            timestamp: data.timestamp || new Date().toISOString(),
            data: data
        };

        // 如果启用了映射，或配置中默认启用了映射
        const useMappedFormat = enableMapping || this.config.propertyMapping.enabled;
        if (useMappedFormat) {
            try {
                const mappedData = propertyMapper.transformForHTTP(data, deviceNumber);
                responseData = {
                    deviceNumber: deviceNumber,
                    timestamp: data.timestamp || new Date().toISOString(),
                    properties: mappedData, // [{identifier, name, value}, ...]
                    format: 'mapped'
                };

                // 如果配置允许，也包含原始数据
                if (this.config.propertyMapping.includeRawData) {
                    responseData.rawData = data;
                }
            } catch (err) {
                logger.error(`属性映射失败: ${err.message}`);
                // 映射失败时回退到原始格式
                responseData.format = 'raw';
                responseData.mappingError = err.message;
            }
        }

        this.sendSuccess(res, responseData);
    }

    /**
     * 获取所有设备的数据
     * GET /api/device/all
     * GET /api/device/all?mapped=true  (启用属性映射)
     */
    handleGetAllDevices(req, res, query) {
        const enableMapping = query?.mapped === 'true'; // 支持查询参数控制映射

        // ✅【新增】限流检查 - 所有设备使用统一标识符，间隔 1 分钟
        if (this.config.rateLimit.enabled) {
            const limitCheck = rateLimiter.checkLimit('__all_devices__', this.config.rateLimit.allDevicesInterval);
            if (!limitCheck.allowed) {
                this.sendError(res, 429, `请求过于频繁，请在 ${limitCheck.remainingTime}ms 后再试`);
                return;
            }
        }

        const allData = dataCache.getAllDeviceData();
        
        if (Object.keys(allData).length === 0) {
            this.sendSuccess(res, {
                message: '暂无设备数据',
                count: 0,
                data: {},
                format: 'raw'
            });
            return;
        }

        // ✅【新增】属性映射处理
        const useMappedFormat = enableMapping || this.config.propertyMapping.enabled;
        
        if (useMappedFormat) {
            try {
                const mappedDevices = {};
                for (const [deviceNumber, rawData] of Object.entries(allData)) {
                    mappedDevices[deviceNumber] = {
                        timestamp: rawData.timestamp || new Date().toISOString(),
                        properties: propertyMapper.transformForHTTP(rawData, deviceNumber),
                        format: 'mapped'
                    };
                    
                    if (this.config.propertyMapping.includeRawData) {
                        mappedDevices[deviceNumber].rawData = rawData;
                    }
                }

                this.sendSuccess(res, {
                    count: Object.keys(mappedDevices).length,
                    data: mappedDevices,
                    format: 'mapped'
                });
                return;
            } catch (err) {
                logger.error(`批量属性映射失败: ${err.message}`);
                // 映射失败时回退到原始格式
            }
        }

        this.sendSuccess(res, {
            count: Object.keys(allData).length,
            data: allData,
            format: 'raw'
        });
    }

    /**
     * 获取设备列表（简化版，仅包含基本信息）
     * GET /api/device/list
     */
    handleGetDeviceList(req, res) {
        const deviceList = dataCache.getDeviceList();

        this.sendSuccess(res, {
            count: deviceList.length,
            devices: deviceList
        });
    }

    /**
     * 获取缓存统计信息
     * GET /api/cache/stats
     */
    handleGetStats(req, res) {
        const stats = dataCache.getStats();

        this.sendSuccess(res, {
            timestamp: new Date().toISOString(),
            ...stats
        });
    }

    /**
     * 清空所有缓存
     * POST /api/cache/clear
     */
    handleClearCache(req, res) {
        if (req.method !== 'POST' && req.method !== 'GET') {
            this.sendError(res, 405, '方法不允许');
            return;
        }

        dataCache.clearAll();
        
        this.sendSuccess(res, {
            message: '缓存已清空'
        });
    }

    /**
     * 获取空闲设备列表
     * GET /api/device/idle?timeout=300000
     */
    handleGetIdleDevices(req, res, query) {
        const timeout = parseInt(query.timeout) || 300000; // 默认 5 分钟
        const idleDevices = dataCache.getIdleDevices(timeout);

        this.sendSuccess(res, {
            timeout: timeout,
            count: idleDevices.length,
            devices: idleDevices
        });
    }

    /**
     * 健康检查
     * GET /api/health
     */
    handleHealth(req, res) {
        this.sendSuccess(res, {
            status: 'ok',
            timestamp: new Date().toISOString()
        });
    }

    /**
     * 获取限流统计信息
     * GET /api/ratelimit/stats
     */
    handleRateLimitStats(req, res) {
        const stats = rateLimiter.getStats();

        this.sendSuccess(res, {
            enabled: this.config.rateLimit.enabled,
            interval: this.config.rateLimit.interval,
            ...stats
        });
    }

    /**
     * 清空限流记录
     * POST /api/ratelimit/clear
     */
    handleRateLimitClear(req, res) {
        if (req.method !== 'POST' && req.method !== 'GET') {
            this.sendError(res, 405, '方法不允许');
            return;
        }

        rateLimiter.clearAll();

        this.sendSuccess(res, {
            message: '限流记录已清空'
        });
    }

    /**
     * 根路径 - 返回 API 文档
     * GET /
     */
    handleRoot(req, res) {
        const apiDocs = {
            service: '透析机数据 HTTP API',
            version: '1.0.0',
            timestamp: new Date().toISOString(),
            rateLimit: {
                enabled: this.config.rateLimit.enabled,
                deviceDataInterval: `${this.config.rateLimit.interval}ms`,
                allDevicesInterval: `${this.config.rateLimit.allDevicesInterval}ms`
            },
            endpoints: {
                '获取指定设备数据': {
                    method: 'GET',
                    path: '/api/device/data',
                    params: { deviceNumber: '设备序号' },
                    example: '/api/device/data?deviceNumber=D001',
                    rateLimit: `${this.config.rateLimit.interval}ms (按设备号)`
                },
                '获取所有设备数据': {
                    method: 'GET',
                    path: '/api/device/all',
                    description: '返回所有设备的完整数据',
                    rateLimit: `${this.config.rateLimit.allDevicesInterval}ms (全局)`
                },
                '获取设备列表': {
                    method: 'GET',
                    path: '/api/device/list',
                    description: '返回设备列表（简化版）'
                },
                '获取缓存统计': {
                    method: 'GET',
                    path: '/api/cache/stats',
                    description: '返回缓存使用情况'
                },
                '获取限流状态': {
                    method: 'GET',
                    path: '/api/ratelimit/stats',
                    description: '返回限流统计信息'
                },
                '清空缓存': {
                    method: 'POST',
                    path: '/api/cache/clear',
                    description: '清空所有缓存数据'
                },
                '清空限流记录': {
                    method: 'POST',
                    path: '/api/ratelimit/clear',
                    description: '清空所有限流记录'
                },
                '获取空闲设备': {
                    method: 'GET',
                    path: '/api/device/idle',
                    params: { timeout: '超时时间(毫秒，默认300000)' },
                    example: '/api/device/idle?timeout=300000'
                },
                '健康检查': {
                    method: 'GET',
                    path: '/api/health'
                }
            }
        };

        this.sendSuccess(res, apiDocs);
    }

    /**
     * 发送成功响应
     */
    sendSuccess(res, data) {
        res.writeHead(200);
        res.end(JSON.stringify({
            code: 0,
            message: 'success',
            data: data,
            timestamp: new Date().toISOString()
        }));
    }

    /**
     * 发送错误响应
     */
    sendError(res, statusCode, message) {
        res.writeHead(statusCode);
        res.end(JSON.stringify({
            code: statusCode,
            message: message,
            timestamp: new Date().toISOString()
        }));
    }

    /**
     * 停止 HTTP 服务
     */
    stop() {
        if (this.server) {
            this.server.close();
            logger.info('HTTP 服务已停止');
        }
    }
}

module.exports = HttpServer;