indexhttps.js

const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');
const { initializeWebSocket, getWebSocketStats } = require('./websocket-server')
const httpServer = express();
const app = express();
const fs = require('fs');
const allowedOrigins = [
  'https://idari.aho.com',
  'https://optik.aho.com',
  'https://mekanik.aho.com',
  'https://bakim.aho.com',
  'https://kalite.aho.com',
  'https://10.0.0.35:4200',
  'http://10.0.0.35:4200',
  'http://localhost:4200',
  'https://localhost:4200',
  'https://127.0.0.1:4200',
  'http://127.0.0.1:4200',
  // Geliştirme için ek originler
  'https://10.0.0.35:3000',
  'http://10.0.0.35:3000'
];

const corsOptions = {
  origin: '*', // Tüm origin'lere izin ver
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH'],
  allowedHeaders: ['Content-Type', 'Authorization', 'Accept', 'X-Requested-With'],
  optionsSuccessStatus: 200,
  maxAge: 86400
};

const port = 3001;
const https = require('https');
const options = {
  // key: fs.readFileSync('./ssl/10.0.0.35+3-key.pem'),     
  // cert: fs.readFileSync('./ssl/10.0.0.35+3.pem')    
};
const server = https.createServer(options, app);

const { reset } = require('nodemon');
const { machine } = require('os');
app.use(express.json());

// Middleware
app.use(cors(corsOptions));
app.use(bodyParser.json({ limit: '50mb' }));
app.use(bodyParser.urlencoded({ extended: true, limit: '50mb' }));
app.use((req, res, next) => {
  const origin = req.headers.origin;
  
  // Origin'e göre dinamik olarak izin ver
  if (origin && allowedOrigins.includes(origin)) {
    res.header('Access-Control-Allow-Origin', origin);
  } else {
    // Geliştirme ortamında tüm origin'lere izin ver (isteğe bağlı)
    res.header('Access-Control-Allow-Origin', '*');
  }
  
  res.header('Access-Control-Allow-Credentials', 'true');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
  
  if (req.method === 'OPTIONS') {
    return res.status(200).end();
  }
  
  next();
});

app.use(express.json());
initializeWebSocket(server);
const apiStatsMiddleware = require('./apiStatsMiddleware');
app.use(apiStatsMiddleware.middleware());
// Route importları
const bilgi_islem = require('./routes/bilgiIslemRoutes');

const dosyaOkuma = require('./dosyaOkuma');
const planlamaCalisma = require('./controllers/planliCalisanFonksiyon');
const planlamaRout = require('./planlama');
const bakimRout = require('./bakim');
const mekanikmRout = require('./mekanik');
const satinAlmaRout = require('./satinalma');
const girisKaliteRout = require('./girisKalite');
const optikUretim = require('./optikUretim');
const portal_anket = require('./routes/portalAnketRoutes');
const portal_km = require('./routes/portalKmRoutes');
const portal_duyru = require('./routes/portalDuyruRoutes');
const portal_egitim = require('./routes/portalEgitimRoutes');
const portal_zimmet = require('./routes/portalZimmetRoutes');
const portal_envanter = require('./routes/portalEnvanterRoutes');
const haberRoutes = require('./routes/portalHaberRoutes');
const cariYonetimRoutes = require('./routes/portalCariYonetimRoutes');
const userRoutes = require('./routes/portalUserRouters');
const uretimKalite = require('./routes/uretimKaliteRoutes.js');
const maliyetRoutes = require('./routes/maliyetRoutes.js');
const maliyetRoutests = require('./routes/maliyetRoutests.js');
const satinAlmaSiparisRoutests = require('./routes/portalSatinAlmaRoutes.js');
const portalMakinaRoutes = require('./routes/portalMakinaRoutes.js');
const portalIsmulakatRoutes = require('./routes/portalIsmulakatRouter.js');
const productRoutes = require('./routes/machinePlan/productRoutes');
const operationRoutes = require('./routes/machinePlan/operationRoutes');
const machineRoutes = require('./routes/machinePlan/machineRoutes');
const orderRoutes = require('./routes/machinePlan/orderRoutes');
const productRoutingRoutes = require('./routes/machinePlan/productRoutingRoutes');
const scheduleRoutes = require('./routes/machinePlan/scheduleRoutes');
const machineCapabilityRoutes = require('./routes/machinePlan/machineCapabilityRoutes');
const dashboardRoutes = require('./routes/machinePlan/dashboardRoutes');
const gelirGiderRoutes = require('./routes/portalGelirGiderRoutes');

// Task reminder servisi
const TaskReminderService = require('./controllers/task-reminder');

// Task controller
const portal_task = require('./controllers/portalTaskController');
app.use('/portal_task', portal_task);

// Route tanımlamaları
app.use('/api/products', productRoutes);
app.use('/api/operations', operationRoutes);
app.use('/api/machines', machineRoutes);
app.use('/api/orders', orderRoutes);
app.use('/api/product-routings', productRoutingRoutes);
app.use('/api/schedules', scheduleRoutes);
app.use('/api/machine-capabilities', machineCapabilityRoutes);
app.use('/api/dashboard', dashboardRoutes);
app.use('/portal_egitim', portal_egitim);
app.use('/', planlamaCalisma);
app.use('/', bilgi_islem);

app.use('/portal_anket', portal_anket);
app.use('/portal_duyuru', portal_duyru);
app.use('/portal_km', portal_km);
app.use('/haber', haberRoutes);
app.use('/portal_zimmet', portal_zimmet);
app.use('/portal_envanter', portal_envanter);
app.use('/portal_gelir_gider', gelirGiderRoutes);
app.use('/portal_cariYonetim', cariYonetimRoutes);
app.use('/portal_user', userRoutes);
app.use('/uretimKalite', uretimKalite);
app.use('/dosya_okuma', dosyaOkuma);
app.use('/maliyet', maliyetRoutes);
app.use('/maliyets', maliyetRoutests);
app.use('/portal_satinalma', satinAlmaSiparisRoutests);
app.use('/portal_ik_mulakat', portalIsmulakatRoutes);
app.use('/portal_makina', portalMakinaRoutes);
app.use('/', optikUretim);
app.use('/', mekanikmRout);
app.use('/', planlamaRout);
app.use('/', bakimRout);
app.use('/', satinAlmaRout);
app.use('/', girisKaliteRout);


// İlk çalıştırmayı anında yapmak için:


// WebSocket istatistikleri endpoint'i
app.get('/websocket/stats', (req, res) => {
  const stats = getWebSocketStats();
  res.json({
    status: 'OK',
    websocket: {
      enabled: true,
      stats: stats || { totalConnections: 0, connectedUsers: [] }
    }
  });
});

// Health check endpoint
app.get('/health', (req, res) => {
  const wsStats = getWebSocketStats();
  res.json({ 
    status: 'OK', 
    timestamp: new Date().toISOString(),
    service: 'Aselsan Backend API',
    websocket: {
      enabled: true,
      connections: wsStats ? wsStats.totalConnections : 0,
      connectedUsers: wsStats ? wsStats.connectedUsers : [],
      serverTime: new Date().toISOString()
    },
    features: {
      taskReminders: true,
      birthdayReminders: true,
      organizationalAlerts: true,
      websocket: true
    }
  });
});

// Task reminder status endpoint
app.get('/task-reminder/status', (req, res) => {
  if (taskReminderService) {
    const status = taskReminderService.getStatus();
    res.json({
      ...status,
      birthdayFeature: true,
      features: ['task_reminders', 'birthday_reminders', 'organizational_alerts']
    });
  } else {
    res.status(500).json({ error: 'Task reminder service not initialized' });
  }
});

// Manuel reminder check endpoint
app.post('/task-reminder/check-now', async (req, res) => {
  try {
    if (taskReminderService) {
      await taskReminderService.checkTaskDeadlines();
      res.json({ 
        message: 'Manual reminder check completed', 
        status: taskReminderService.getStatus(),
        features: {
          taskReminders: true,
          birthdayReminders: true
        }
      });
    } else {
      res.status(500).json({ error: 'Task reminder service not initialized' });
    }
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Birthday endpoints
app.get('/birthday-reminder/status', (req, res) => {
  if (taskReminderService) {
    try {
      const status = taskReminderService.getBirthdayStatus();
      res.json({
        ...status,
        service: 'Birthday Reminder Service',
        organizationalStructure: true,
        hierarchyBased: true
      });
    } catch (error) {
      res.status(500).json({ 
        error: 'Birthday service not available',
        details: error.message 
      });
    }
  } else {
    res.status(500).json({ error: 'Task reminder service not initialized' });
  }
});

app.post('/birthday-reminder/check-now', async (req, res) => {
  try {
    if (taskReminderService) {
      const result = await taskReminderService.checkBirthdayReminders();
      res.json({ 
        message: 'Manual birthday check completed', 
        result: result,
        status: taskReminderService.getStatus(),
        timestamp: new Date().toISOString()
      });
    } else {
      res.status(500).json({ error: 'Task reminder service not initialized' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: 'Birthday check failed',
      details: error.message 
    });
  }
});

app.get('/birthday-reminder/stats', async (req, res) => {
  try {
    if (taskReminderService) {
      const stats = await taskReminderService.getBirthdayStats();
      res.json(stats);
    } else {
      res.status(500).json({ error: 'Task reminder service not initialized' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: 'Failed to get birthday stats',
      details: error.message 
    });
  }
});

// Yaklaşan doğum günleri listesi
app.get('/birthday-reminder/upcoming', async (req, res) => {
  try {
    if (taskReminderService) {
      const upcoming = await taskReminderService.getUpcomingBirthdaysForAPI();
      res.json({
        count: upcoming.length,
        upcoming: upcoming,
        period: 'next_7_days'
      });
    } else {
      res.status(500).json({ error: 'Task reminder service not initialized' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: 'Failed to get upcoming birthdays',
      details: error.message 
    });
  }
});

// Bugün doğum günü olanlar
app.get('/birthday-reminder/today', async (req, res) => {
  try {
    if (taskReminderService) {
      const todayBirthdays = await taskReminderService.getTodaysBirthdays();
      res.json({
        count: todayBirthdays.length,
        birthdays: todayBirthdays,
        date: new Date().toISOString().split('T')[0]
      });
    } else {
      res.status(500).json({ error: 'Task reminder service not initialized' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: 'Failed to get today\'s birthdays',
      details: error.message 
    });
  }
});

// WebSocket test endpoint
app.get('/websocket-test', (req, res) => {
  const token = req.query.token || 'test';
  const testUrl = `ws://10.0.0.35:3000/ws?token=${token}`;
  
  res.json({
    test: 'WebSocket Connection Test',
    url: testUrl,
    instructions: 'Open browser console and run:',
    javascript: `const ws = new WebSocket("${testUrl}"); ws.onopen = () => console.log("✅ Connected"); ws.onmessage = (e) => console.log("📨:", e.data);`
  });
});

// Notification service status
app.get('/notification-service/status', (req, res) => {
  res.json({
    status: 'OK',
    service: 'Notification Service',
    features: {
      taskNotifications: true,
      birthdayNotifications: true,
      realTimeUpdates: true,
      unreadCount: true
    },
    endpoints: {
      getNotifications: '/portal_task/notifications',
      getUnreadCount: '/portal_task/notifications/unread-count',
      markAsRead: '/portal_task/notifications/:id/read',
      markAllRead: '/portal_task/notifications/mark-all-read'
    }
  });
});

// WebSocket durumu
app.get('/ws-status', (req, res) => {
  const stats = getWebSocketStats();
  res.json({
    server_time: new Date().toISOString(),
    ws_enabled: true,
    stats: stats || { totalConnections: 0, connectedUsers: [] }
  });
});

// Task reminder servisini başlat
let taskReminderService;

const startReminderService = () => {
  try {
    taskReminderService = new TaskReminderService();
    taskReminderService.start();
    console.log('✅ Task reminder service started successfully');
    console.log('🎂 Birthday reminder system: ENABLED');
    console.log('🏢 Organizational hierarchy: INTEGRATED');
  } catch (error) {
    console.error('❌ Failed to start task reminder service:', error);
  }
};

// Graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down gracefully');
  if (taskReminderService) {
    taskReminderService.stop();
    console.log('🎂 Birthday reminder service stopped');
  }
  process.exit(0);
});

process.on('SIGINT', () => {
  console.log('SIGINT received, shutting down gracefully');
  if (taskReminderService) {
    taskReminderService.stop();
    console.log('🎂 Birthday reminder service stopped');
  }
  process.exit(0);
});

// Handle uncaught exceptions
process.on('uncaughtException', (error) => {
  console.error('Uncaught Exception:', error);
  if (taskReminderService) {
    taskReminderService.stop();
    console.log('🎂 Birthday reminder service stopped due to error');
  }
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  if (taskReminderService) {
    taskReminderService.stop();
    console.log('🎂 Birthday reminder service stopped due to unhandled rejection');
  }
  process.exit(1);
});
server.listen(port, '10.0.0.35', () => {
    startReminderService();

  console.log('HTTPS server running on port 3000');
});

module.exports = { app, server };
// app.listen(3001, '10.0.0.35', () => {
// });