const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const path = require('path');
const methodOverride = require('method-override');
const request = require('request');
const restream = require('restream');
const app = express();
app.set('host', 'sportswatcher.ddns.net');
const fs = require('fs');
const fetch = require('node-fetch');
const http = require('http').createServer(app);
const { exec } = require('child_process');
const { spawn } = require('child_process');
const io = require('socket.io')(http, {
  cors: {
    origin: "*",  // Adjust this according to your needs
    methods: ["GET", "POST"],
		debug : true,
		transports: ['websocket']
  }
});


app.use(express.json()); // Parse JSON bodies
app.use(express.urlencoded({ extended: true })); // Parse URL-encoded bodies
app.use(cors()); // Enable CORS
app.use(methodOverride('_method')); // Enable method override

// Replace with your MongoDB connection string
const connectionString = 'mongodb://localhost:27017/streaming';

// Connect to MongoDB
mongoose
  .connect(connectionString, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  })
  .then(() => {
    console.log('Connected to MongoDB');
  })
  .catch((error) => {
    console.error('Failed to connect to MongoDB', error);
  });

// Define a Mongoose schema for our Game model
const gameSchema = new mongoose.Schema({
  title: String,
  streamLink: String,
  sport: String,
});

const chatMessageSchema = new mongoose.Schema({
  username: String,
  content: String,
  timestamp: { type: Date, default: Date.now }
});

const ChatMessage = mongoose.model('ChatMessage', chatMessageSchema);

io.on('connection', (socket) => {
    console.log('a user connected');

    socket.on('chat message', (msg) => {
        io.emit('message', msg); // broadcasting the message to all clients
    });

    socket.on('disconnect', () => {
        console.log('user disconnected');
    });
});

// Create the Game model
const Game = mongoose.model('Game', gameSchema);

// Serve static files from the public directory
app.use(express.static(path.join(__dirname, 'public')));

const proxyAddress = 'http://localhost:8080/';
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

// A function that returns a modified URL for .ts files
function getTSURL(targetURL) {
  const baseURL = getBaseURL();
  return baseURL + 'ts/' + targetURL.replace('https://', '');
}

app.get('/chat-messages', async (req, res) => {
  try {
    const messages = await ChatMessage.find().sort({timestamp: -1}).limit(50); // get the last 50 messages
    res.send(messages);
  } catch (error) {
    res.status(500).send(error);
  }
});

app.use('/proxy/', (req, res) => {
    const fullURL = req.protocol + '://' + req.get('host') + req.originalUrl;
    const { pathname, search } = new URL(fullURL);
    const targetURL = pathname.replace('/proxy/', 'https://') + search;

    const curl = spawn('curl', [
        '-H', 'Origin: https://www.nolive.me',
        '-H', 'Referer: https://www.nolive.me/',
        '-H', 'User-Agent: Mozilla/5.0...',
        // Add any other headers you need
        targetURL
    ]);

    curl.stdout.pipe(res);
    curl.stderr.on('data', (data) => {
        console.error(`curl stderr: ${data}`);
    });

    curl.on('close', (code) => {
        if (code !== 0) {
            console.error(`curl process exited with code ${code}`);
        }
    });
});

// A new route for handling .ts requests
app.use('/ts/', (req, res) => {
  const fullURL = req.protocol + '://' + req.get('host') + req.originalUrl;
  const { pathname, search } = new URL(fullURL);
  const targetURL = pathname.replace('/ts/', 'https://') + search;
	const proxyHeaders = {
		'Origin': 'https://www.nolive.me',
		'Referer': 'https://www.nolive.me/',
		'User-Agent': 'Mozilla/5.0...',
		'Host': 'ed-t3.edghst.me'
		}

  const proxyRequestOptions = {
    url: targetURL,
		method: req.method,
		headers: proxyHeaders,
		followRedirect: true
  };
  const proxyRequest = request(proxyRequestOptions);

  proxyRequest.on('response', function(sourceResponse) {
    Object.keys(sourceResponse.headers).forEach(headerKey => {
      res.setHeader(headerKey, sourceResponse.headers[headerKey]);
    });
    let contentType = sourceResponse.headers['content-type'];
    if (!contentType || contentType === 'application/octet-stream') {
      res.setHeader('Content-Type', 'video/MP2T');
    }
    res.setHeader('Access-Control-Allow-Origin', '*');
    sourceResponse.pipe(res);
  });

  proxyRequest.on('error', function(err) {
    console.error('Proxy Error for URL:', targetURL, 'Error:', err.message);
    res.status(500).send('Proxy Error');
  });

  res.on('error', (err) => {
    console.error('Error during response pipe:', err);
  });

  req.pipe(restream()).pipe(proxyRequest);
});

function getBaseURL() {
  return `http://${app.get('host')}/`;
}

app.get('/', (req, res) => {
  res.render('main.ejs');
});

// Route for serving the admin panel
app.get('/admin', async (req, res) => {
  try {
    const games = await Game.find();
    res.render('admin.ejs', { videos: games });
  } catch (error) {
    res.status(500).send(error);
  }
});

// Route for getting all games
app.get('/games', async (req, res) => {
  try {
    const games = await Game.find();
    res.send(games);
  } catch (error) {
    res.status(500).send(error);
  }
});

// Route for creating a new game
app.post('/games', async (req, res) => {
  try {
    const game = new Game(req.body);
    await game.save();
    res.redirect('/admin');
  } catch (error) {
    res.status(500).send(error);
  }
});

app.put('/games/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { title, streamLink, sport } = req.body;
    const updatedGame = await Game.findByIdAndUpdate(id, { title, streamLink, sport }, { new: true });
    res.redirect('/admin');
  } catch (error) {
    res.status(500).send(error);
  }
});

// Route for deleting a game
app.delete('/games/:id', async (req, res) => {
  try {
    await Game.deleteOne({ _id: req.params.id });
    res.redirect('/admin');
  } catch (error) {
    res.status(500).send(error);
  }
});
io.on('connect_error', (error) => {
    console.log('Connection Error: ', error);
});
// Start the server
const port = process.env.PORT || 3000;
http.listen(port, () => console.log(`Server running on port ${port}`));