server.js

const express = require('express');
const cors = require('cors');
const path = require('path');
const multer = require('multer');
const fs = require('fs');
const mc = require('minecraft-protocol');
const app = express();
const port = process.env.PORT || 3000;

// 配置文件上传
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    const uploadDir = path.join('public', file.fieldname === 'resourcepack' ? 'resourcepacks' : 'uploads');
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }
    cb(null, uploadDir);
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({
  storage: storage,
  limits: {
    fileSize: 50 * 1024 * 1024 // 限制50MB
  },
  fileFilter: function (req, file, cb) {
    if (file.fieldname === 'icon') {
      const allowedTypes = ['image/jpeg', 'image/png', 'image/gif', 'image/svg+xml'];
      if (allowedTypes.includes(file.mimetype)) {
        cb(null, true);
      } else {
        cb(new Error('不支持的文件类型'));
      }
    } else if (file.fieldname === 'resourcepack') {
      // 资源包文件类型检查
      if (file.mimetype === 'application/zip' || file.mimetype === 'application/x-zip-compressed') {
        cb(null, true);
      } else {
        cb(new Error('资源包必须是ZIP格式'));
      }
    } else {
      cb(new Error('未知的文件类型'));
    }
  }
});

// 中间件
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// 错误处理中间件
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({
    error: '服务器内部错误',
    message: process.env.NODE_ENV === 'development' ? err.message : undefined
  });
});

// 模拟数据
const servers = [
  {
    id: 1,
    name: '生存服务器',
    ip: 'mc.example.com',
    description: '原版生存服务器，支持多人游戏，定期举办活动',
    image: '/images/default-server.svg',
    ping: 35,
    version: '1.20.4',
    players: {
      online: 128,
      max: 200
    },
    features: ['生存', '经济系统', '领地', '副本'],
    resourcepack: null // 添加资源包字段
  },
  {
    id: 2,
    name: '创造服务器',
    ip: 'creative.example.com',
    description: '创造模式服务器，自由建造，支持世界编辑',
    image: '/images/default-server.svg',
    ping: 42,
    version: '1.20.4',
    players: {
      online: 64,
      max: 100
    },
    features: ['创造', '世界编辑', '建筑比赛']
  },
  {
    id: 3,
    name: '小游戏服务器',
    ip: 'minigames.example.com',
    description: '各种有趣的小游戏，包括空岛战争、躲猫猫等',
    image: '/images/default-server.svg',
    ping: 56,
    version: '1.20.4',
    players: {
      online: 256,
      max: 500
    },
    features: ['小游戏', '排位系统', '组队系统']
  }
];

// 模拟入驻申请数据
let applications = [
  {
    id: 1,
    applicant: '张三',
    serverName: '测试服务器',
    serverIP: 'test.example.com',
    version: '1.20.4',
    description: '这是一个测试服务器',
    features: ['生存', '小游戏'],
    contact: '12345678901',
    status: '待审核',
    createdAt: '2024-01-20T08:00:00.000Z'
  }
];

// MC ping 功能
async function pingMinecraftServer(host, port = 25565) {
  return new Promise((resolve, reject) => {
    mc.ping({ host, port }, (err, response) => {
      if (err) {
        reject(err);
      } else {
        resolve({
          version: response.version.name,
          protocol: response.version.protocol,
          players: {
            online: response.players.online,
            max: response.players.max,
            sample: response.players.sample
          },
          description: response.description,
          favicon: response.favicon
        });
      }
    });
  });
}

// API路由
// 获取服务器列表
app.get('/api/servers', (req, res) => {
  try {
    const { search, sort } = req.query;
    let filteredServers = [...servers];

    // 搜索过滤
    if (search) {
      const searchLower = search.toLowerCase();
      filteredServers = filteredServers.filter(server => 
        server.name.toLowerCase().includes(searchLower) ||
        server.description.toLowerCase().includes(searchLower) ||
        server.features.some(feature => feature.toLowerCase().includes(searchLower))
      );
    }

    // 排序
    if (sort) {
      switch (sort) {
        case 'players':
          filteredServers.sort((a, b) => b.players.online - a.players.online);
          break;
        case 'ping':
          filteredServers.sort((a, b) => a.ping - b.ping);
          break;
        case 'name':
          filteredServers.sort((a, b) => a.name.localeCompare(b.name));
          break;
      }
    }

    res.json(filteredServers);
  } catch (error) {
    next(error);
  }
});

// 获取单个服务器信息
app.get('/api/servers/:id', (req, res) => {
  try {
    const server = servers.find(s => s.id === parseInt(req.params.id));
    if (server) {
      res.json(server);
    } else {
      res.status(404).json({ error: '服务器未找到' });
    }
  } catch (error) {
    next(error);
  }
});

// 添加服务器
app.post('/api/servers', (req, res) => {
  try {
    const newServer = {
      id: servers.length + 1,
      ...req.body,
      image: '/images/default-server.svg',
      ping: Math.floor(Math.random() * 100),
      players: {
        online: 0,
        max: req.body.players?.max || 100
      }
    };
    servers.push(newServer);
    res.status(201).json(newServer);
  } catch (error) {
    next(error);
  }
});

// 更新服务器
app.put('/api/servers/:id', (req, res) => {
  try {
    const index = servers.findIndex(s => s.id === parseInt(req.params.id));
    if (index !== -1) {
      servers[index] = {
        ...servers[index],
        ...req.body
      };
      res.json(servers[index]);
    } else {
      res.status(404).json({ error: '服务器未找到' });
    }
  } catch (error) {
    next(error);
  }
});

// 删除服务器
app.delete('/api/servers/:id', (req, res) => {
  try {
    const index = servers.findIndex(s => s.id === parseInt(req.params.id));
    if (index !== -1) {
      servers.splice(index, 1);
      res.status(204).end();
    } else {
      res.status(404).json({ error: '服务器未找到' });
    }
  } catch (error) {
    next(error);
  }
});

// 获取服务器状态
app.get('/api/servers/:id/status', async (req, res) => {
  try {
    const server = servers.find(s => s.id === parseInt(req.params.id));
    if (server) {
      try {
        // 解析服务器 IP 和端口
        const [host, port] = server.ip.split(':');
        const mcStatus = await pingMinecraftServer(host, parseInt(port) || 25565);
        
        const status = {
          online: true,
          version: mcStatus.version,
          players: mcStatus.players,
          description: mcStatus.description,
          favicon: mcStatus.favicon,
          lastUpdate: new Date().toISOString()
        };
        
        res.json(status);
      } catch (error) {
        // 如果 ping 失败,返回离线状态
        res.json({
          online: false,
          error: '服务器可能离线',
          lastUpdate: new Date().toISOString()
        });
      }
    } else {
      res.status(404).json({ error: '服务器未找到' });
    }
  } catch (error) {
    next(error);
  }
});

// 获取入驻申请列表
app.get('/api/applications', (req, res) => {
  try {
    res.json(applications);
  } catch (error) {
    next(error);
  }
});

// 提交入驻申请
app.post('/api/applications', (req, res) => {
  try {
    const newApplication = {
      id: applications.length + 1,
      ...req.body,
      status: '待审核',
      createdAt: new Date().toISOString()
    };
    applications.push(newApplication);
    res.status(201).json(newApplication);
  } catch (error) {
    next(error);
  }
});

// 上传服务器图标
app.post('/api/upload', upload.single('icon'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: '没有上传文件' });
    }
    const filePath = '/uploads/' + req.file.filename;
    res.json({ url: filePath });
  } catch (error) {
    next(error);
  }
});

// 更新申请状态并同步服务器
app.put('/api/applications/:id', (req, res) => {
  try {
    const index = applications.findIndex(a => a.id === parseInt(req.params.id));
    if (index !== -1) {
      const { status } = req.body;
      
      // 如果申请已经有了最终状态（已通过或已拒绝），则不允许再次修改
      if (applications[index].status === '已通过' || applications[index].status === '已拒绝') {
        return res.status(400).json({ error: '该申请已经处理过了' });
      }

      // 更新申请状态
      applications[index] = {
        ...applications[index],
        status: status === 'approved' ? '已通过' : '已拒绝',
        updatedAt: new Date().toISOString()
      };

      // 如果申请通过，自动创建服务器
      if (status === 'approved') {
        const newServer = {
          id: servers.length + 1,
          name: applications[index].serverName,
          ip: applications[index].serverIP,
          description: applications[index].description,
          version: applications[index].version,
          features: applications[index].features,
          image: applications[index].icon || '/images/default-server.svg',
          ping: Math.floor(Math.random() * 100),
          players: {
            online: 0,
            max: 100
          }
        };
        servers.push(newServer);

        // 返回同步后的数据
        res.json({
          application: applications[index],
          server: newServer
        });
      } else {
        res.json(applications[index]);
      }
    } else {
      res.status(404).json({ error: '申请未找到' });
    }
  } catch (error) {
    next(error);
  }
});

// 上传资源包
app.post('/api/servers/:id/resourcepack', upload.single('resourcepack'), (req, res) => {
  try {
    if (!req.file) {
      return res.status(400).json({ error: '没有上传文件' });
    }

    const server = servers.find(s => s.id === parseInt(req.params.id));
    if (!server) {
      // 删除已上传的文件
      fs.unlinkSync(path.join(__dirname, 'public', req.file.path));
      return res.status(404).json({ error: '服务器未找到' });
    }

    // 如果服务器之前有资源包,删除旧文件
    if (server.resourcepack) {
      const oldPath = path.join(__dirname, 'public', server.resourcepack);
      if (fs.existsSync(oldPath)) {
        fs.unlinkSync(oldPath);
      }
    }

    // 更新服务器的资源包路径
    const resourcepackPath = '/resourcepacks/' + req.file.filename;
    server.resourcepack = resourcepackPath;

    res.json({ 
      url: resourcepackPath,
      filename: req.file.originalname
    });
  } catch (error) {
    next(error);
  }
});

// 获取资源包信息
app.get('/api/servers/:id/resourcepack', (req, res) => {
  try {
    const server = servers.find(s => s.id === parseInt(req.params.id));
    if (!server) {
      return res.status(404).json({ error: '服务器未找到' });
    }

    if (!server.resourcepack) {
      return res.status(404).json({ error: '该服务器没有资源包' });
    }

    res.json({
      url: server.resourcepack,
      filename: path.basename(server.resourcepack)
    });
  } catch (error) {
    next(error);
  }
});

// 处理404错误
app.use((req, res) => {
  if (req.path.startsWith('/api')) {
    res.status(404).json({ error: '接口未找到' });
  } else {
    res.sendFile(path.join(__dirname, 'public', 'index.html'));
  }
});

// 启动服务器
app.listen(port, () => {
  console.log(`服务器运行在 http://localhost:${port}`);
});