#!/bin/bash

# Final fix for all issues

# Colors
GREEN='\033[0;32m'
BLUE='\033[0;34m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'

echo "========================================="
echo "Final Fix for AirwavePBX"
echo "========================================="
echo

# First, let's check the API logs to see why it's failing
echo -e "${BLUE}[INFO]${NC} Checking API logs..."
pm2 logs airwavepbx-api --lines 20 --nostream

# Copy missing logo
echo -e "${BLUE}[INFO]${NC} Copying logo..."
if [ -f "/opt/airwavepbx/logos/airwave-logo.png" ]; then
    cp /opt/airwavepbx/logos/airwave-logo.png /opt/airwavepbx/public/logo.png
elif [ -f "/opt/airwavepbx/logos/logo.png" ]; then
    cp /opt/airwavepbx/logos/logo.png /opt/airwavepbx/public/logo.png
else
    # Create a placeholder if no logo exists
    echo -e "${YELLOW}[WARNING]${NC} No logo found, creating placeholder..."
    mkdir -p /opt/airwavepbx/public
    # Create a simple SVG logo as placeholder
    cat > /opt/airwavepbx/public/logo.svg << 'EOF'
<svg width="200" height="50" xmlns="http://www.w3.org/2000/svg">
  <text x="10" y="35" font-family="Arial" font-size="24" fill="#3b82f6">AirwavePBX</text>
</svg>
EOF
fi

# Fix the API to start on correct port
echo -e "${BLUE}[INFO]${NC} Checking API configuration..."
cd /opt/airwavepbx

# Make sure all required npm packages are installed
echo -e "${BLUE}[INFO]${NC} Installing API dependencies..."
cd /opt/airwavepbx/api
npm install express cors body-parser sqlite3 bcryptjs jsonwebtoken asterisk-manager socket.io dotenv

# Update Nginx to handle API correctly
echo -e "${BLUE}[INFO]${NC} Updating Nginx configuration..."
source /etc/airwavepbx/airwavepbx.env

cat > /etc/nginx/sites-available/airwavepbx << NGINX_EOF
server {
    listen 80;
    server_name $DOMAIN;

    # Main application
    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host \$host;
        proxy_cache_bypass \$http_upgrade;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }

    # API proxy
    location /api {
        proxy_pass http://localhost:3001;
        proxy_http_version 1.1;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
        proxy_set_header Content-Type application/json;
        proxy_read_timeout 90;
    }

    # WebSocket proxy
    location /ws {
        proxy_pass http://localhost:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
    }

    # Static files
    location /logo.png {
        alias /opt/airwavepbx/public/logo.png;
    }
    
    location /logo.svg {
        alias /opt/airwavepbx/public/logo.svg;
    }
}
NGINX_EOF

# Test and reload Nginx
nginx -t && systemctl reload nginx

# Create a simpler API server that will definitely work
echo -e "${BLUE}[INFO]${NC} Creating simplified API server..."
cat > /opt/airwavepbx/api/server-simple.js << 'EOF'
const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');
const sqlite3 = require('sqlite3').verbose();
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const path = require('path');
const fs = require('fs');

// Load environment
const envPath = '/etc/airwavepbx/airwavepbx.env';
if (fs.existsSync(envPath)) {
  require('dotenv').config({ path: envPath });
}

const app = express();
const PORT = process.env.API_PORT || 3001;

// Middleware
app.use(cors());
app.use(bodyParser.json());

// Database
const dbPath = process.env.DATABASE_PATH || '/var/lib/airwavepbx/data/airwavepbx.db';
const dbDir = path.dirname(dbPath);
if (!fs.existsSync(dbDir)) {
  fs.mkdirSync(dbDir, { recursive: true });
}

const db = new sqlite3.Database(dbPath);

// Initialize database
db.serialize(() => {
  db.run(`CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    username TEXT UNIQUE NOT NULL,
    password TEXT NOT NULL,
    email TEXT,
    role TEXT DEFAULT 'user',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )`);

  db.run(`CREATE TABLE IF NOT EXISTS extensions (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    extension TEXT UNIQUE NOT NULL,
    name TEXT NOT NULL,
    context TEXT DEFAULT 'internal',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  )`);

  // Create default admin
  const defaultPassword = bcrypt.hashSync('admin', 10);
  db.run(`INSERT OR IGNORE INTO users (username, password, email, role) 
          VALUES ('admin', ?, 'admin@localhost', 'admin')`, [defaultPassword]);
});

// Auth middleware
const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) return res.sendStatus(401);

  jwt.verify(token, process.env.JWT_SECRET || 'default-secret', (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
};

// Routes
app.get('/api', (req, res) => {
  res.json({ status: 'ok', version: '2.0.0' });
});

app.post('/api/auth/login', (req, res) => {
  const { username, password } = req.body;
  
  db.get('SELECT * FROM users WHERE username = ?', [username], async (err, user) => {
    if (err || !user) {
      return res.status(400).json({ error: 'Invalid credentials' });
    }
    
    const validPassword = await bcrypt.compare(password, user.password);
    if (!validPassword) {
      return res.status(400).json({ error: 'Invalid credentials' });
    }
    
    const token = jwt.sign(
      { id: user.id, username: user.username, role: user.role },
      process.env.JWT_SECRET || 'default-secret',
      { expiresIn: '24h' }
    );
    
    res.json({ token, user: { id: user.id, username: user.username, role: user.role } });
  });
});

app.get('/api/extensions', authenticateToken, (req, res) => {
  db.all('SELECT * FROM extensions', (err, rows) => {
    if (err) return res.status(500).json({ error: 'Database error' });
    res.json(rows || []);
  });
});

app.post('/api/extensions', authenticateToken, (req, res) => {
  const { extension, name, context } = req.body;
  
  db.run('INSERT INTO extensions (extension, name, context) VALUES (?, ?, ?)',
    [extension, name, context || 'internal'],
    function(err) {
      if (err) return res.status(500).json({ error: err.message });
      res.json({ id: this.lastID, extension, name, context: context || 'internal' });
    }
  );
});

app.delete('/api/extensions/:id', authenticateToken, (req, res) => {
  db.run('DELETE FROM extensions WHERE id = ?', [req.params.id], (err) => {
    if (err) return res.status(500).json({ error: err.message });
    res.json({ success: true });
  });
});

app.get('/api/dashboard/stats', authenticateToken, (req, res) => {
  const stats = {
    totalExtensions: 0,
    activeCalls: 0,
    systemStatus: 'online',
    uptime: process.uptime()
  };
  
  db.get('SELECT COUNT(*) as count FROM extensions', (err, row) => {
    if (!err && row) stats.totalExtensions = row.count;
    res.json(stats);
  });
});

app.get('/api/system/status', authenticateToken, (req, res) => {
  res.json({
    asterisk: 'offline',
    database: 'connected',
    uptime: process.uptime()
  });
});

// Handle all other API routes
app.use('/api/*', (req, res) => {
  res.status(404).json({ error: 'Not found' });
});

// Start server
app.listen(PORT, '0.0.0.0', () => {
  console.log(`API server running on port ${PORT}`);
});
EOF

# Use the simple server
cp /opt/airwavepbx/api/server-simple.js /opt/airwavepbx/api/server.js

# Restart services
echo -e "${BLUE}[INFO]${NC} Restarting services..."
pm2 restart all

# Wait a bit
sleep 5

# Check status
echo
echo -e "${BLUE}[INFO]${NC} Service status:"
pm2 status

# Test API
echo
echo -e "${BLUE}[INFO]${NC} Testing API..."
API_RESPONSE=$(curl -s http://localhost:3001/api)
echo "API Response: $API_RESPONSE"

# Test through Nginx
echo
echo -e "${BLUE}[INFO]${NC} Testing through Nginx..."
NGINX_API=$(curl -s http://localhost/api)
echo "Nginx API Response: $NGINX_API"

# Final test
echo
echo "========================================="
echo "Final Status"
echo "========================================="
echo
echo "Frontend URL: http://$DOMAIN"
echo "API Status: $API_RESPONSE"
echo
echo "You should now be able to:"
echo "1. Access http://$DOMAIN"
echo "2. Login with admin/admin"
echo
echo "If you still see 502 errors, check:"
echo "- pm2 logs airwavepbx-api"
echo "- systemctl status nginx"
echo "- tail -f /var/log/nginx/error.log"