import compression from 'compression';
import cookieParser from 'cookie-parser';
import cors from 'cors';
import express from 'express';
import moment from 'moment-timezone';
import 'express-async-errors';
import { Op, Sequelize } from 'sequelize';
import fileUpload from 'express-fileupload';
import helmet from 'helmet';
import cron from 'node-cron';
import swaggerUi from 'swagger-ui-express';
import './config/config.js';
import './config/index.js';
import swaggerSpec from './config/swagger-config.js';
import { logger } from './config/winston-config.js';
import logRequest from './helper/logRequest.js';
import { deletePdfs } from './helper/pdfGeneration.js';
import errorHandler from './middleware/errorHandler.js';
import requestLogger from './middleware/requestLogger.js';
import sanitizeMiddleware from './middleware/sanitize.js';
import swaggerAuth from './middleware/swaggerAuth.js';
import './models/index.js';
import apiRouter from './routes/index.js';
import { runCronJob } from './helper/questionsCron.js';
import User from './models/User.js';
import FormData from './models/formDataModel.js';
import { postQuestions } from './api/Questions/service.js';
import usersEventsFailureCron from './helper/eventUpdation.js';
import deleteOldTempFormData from './helper/deleteTempData.js';
import Event from './models/Event.js';

// import urlSigner from './middleware/usrlSigner.js';
// import { deletePdf, sendReport } from './api/website/service.js';
// import { getMetricsData } from './modules/Statistics/index.js';

const app = express();

app.use(helmet());
app.use(compression());
// app.use(
//   cors({
//     origin: [
//       /^(http|https):\/\/(localhost)(:\d+)?$/, // Localhost URLs
//       /^https:\/\/[a-z0-9-]+\.inc\d+\.devtunnels\.ms(\/.*)?$/, // Dev Tunnels URLs
//       process.env.WEB_DOMAIN, // Your web domain
//       process.env.WEB_DOMAIN_ADMIN, // Your admin web domain
//     ],
//     credentials: true,
//   })
// );

// app.use(
//   cors({
//     origin: [
//       /^(http|https):\/\/(localhost)(:\d+)?$/, // Localhost URLs
//       /^https:\/\/[a-z0-9-]+\.inc\d+\.devtunnels\.ms(\/.*)?$/, // Dev Tunnels URLs
//       process.env.WEB_DOMAIN, // Your web domain
//       process.env.WEB_DOMAIN_ADMIN, // Your admin web domain
//     ],
//     methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
//     allowedHeaders: ['Content-Type', 'Authorization'],
//     credentials: true,
//   })
// );

app.use(
  cors({
    origin: '*', // Accept all origins
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'], // Accept all common HTTP methods
    allowedHeaders: '*', // Allow all headers
    credentials: true, // Allow cookies, if needed
  })
);

app.use(express.json());
app.use(express.urlencoded({ limit: '300mb', extended: true }));
app.use(cookieParser());
app.use(fileUpload());

if (process.env.NODE_ENV !== 'production') {
  logRequest(app);
}

app.use('/', express.static('public'));

app.use(sanitizeMiddleware);
app.use(requestLogger);

app.use(
  '/api-docs',
  swaggerAuth,
  swaggerUi.serve,
  swaggerUi.setup(swaggerSpec)
);
app.use('/api', apiRouter);

app.use(errorHandler);

app.get('/', (req, res) => {
  res.send('API WORKING FINE!!');
});

const PORT = process.env.PORT || 3000;

process.on('uncaughtException', (error) => {
  logger.error(`Uncaught Exception: ${error.message}\n${error.stack}`);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error(`Unhandled Rejection: ${reason}\n${promise}`);
});

const server = app.listen(PORT, async () => {
  logger.info(`Server started successfully on port: ${PORT}`);
  logger.info(`App: http://localhost:${PORT}`);
  logger.info(`Swagger: http://localhost:${PORT}/api-docs`);
});

server.on('error', (error) => {
  if (error.code === 'EADDRINUSE') {
    logger.error(`Port ${PORT} is already in use. Trying another port...`);
    process.exit(1);
  } else if (error.code === 'EACCES') {
    logger.error(`Permission denied. Cannot access port ${PORT}.`);
    process.exit(1);
  } else {
    logger.error('Server error:', error);
    process.exit(1);
  }
});

// ------------->>> Cron section <<<----------------
cron.schedule('0 0 * * *', async () => {
  await deletePdfs()
    .then(() => console.log('Cron ran successfully'))
    .catch(() => console.log('Something went wrong.'));
});

cron.schedule('*/4 * * * * *', async () => {
  try {
    const users = await User.findAll({
      where: {
        is_deleted: false,
        status: 'active',
        eventStatus: 'pending',
      },
      raw: true,
    });

    for (const user of users) {
      const userId = user.id;

      // Fetch form data for this user
      const formData = await FormData.findOne({
        where: {
          user_id: userId,
          status: { [Op.notIn]: ['processing', 'completed'] },
        },
        raw: true,
      });

      if (formData) {
        const result = await runCronJob(formData, userId);
        console.log(`Cron ran successfully for user: ${userId}`);
        console.log(`User ${userId} processing result: ${result}`);
      }
    }
  } catch (error) {
    console.error('Something went wrong in the cron job:', error);
  }
});

cron.schedule('*/30 * * * *', async () => {
  const formData = await FormData.findOne({
    where: {
      [Op.or]: [
        { Data: null }, // Check if Data is NULL
        Sequelize.where(
          Sequelize.cast(Sequelize.col('Data'), 'text'),
          Op.eq,
          '{}'
        ), // Check if Data is an empty JSON object
        Sequelize.where(
          Sequelize.cast(Sequelize.col('Data'), 'text'),
          Op.eq,
          '[]'
        ), // Check if Data is an empty JSON array
      ],
    },
    raw: true,
  });
  await postQuestions(formData.userData, formData.user_id)
    .then(() => console.log('Cron ran successfully'))
    .catch(() => console.log('Something went wrong.'));
});

cron.schedule('* * * * *', async () => {
  const startTime = moment().format('YYYY-MM-DD HH:mm:ss');
  console.log(`Task started at: ${startTime}`);
  await usersEventsFailureCron();
  const endTime = moment().format('YYYY-MM-DD HH:mm:ss');
  console.log(`Task completed at: ${endTime}`);
});

// cron.schedule('0 0 * * *', async () => {
//   const startTime = moment().format('YYYY-MM-DD HH:mm:ss');
//   console.log(`TempFormData cleanup started at: ${startTime}`);
//   await deleteOldTempFormData();
//   const endTime = moment().format('YYYY-MM-DD HH:mm:ss');
//   console.log(`TempFormData cleanup completed at: ${endTime}`);
// });