const express = require('express');
const argon2 = require('argon2');
const {
    initDb,
    getAllArticles,
    getArticle,
    createArticle,
    updateArticle,
    deleteArticle,
    searchArticles,
    createUser,
    getUserByUsername,
    getUserByEmail,
    getUserById,
    getAllUsers,
    updateUserRole,
    deleteUser,
    getOwnedDrafts,
    getAllCategories,
    getAllTags,
    getArticleCategories,
    getArticleTags,
    getOrCreateCategory,
    getOrCreateTag,
    setArticleCategories,
    setArticleTags
} = require('./db');
const { generateToken, authenticateToken, authorizeRoles } = require('./auth');
const app = express();
const cors = require('cors');
const msal = require('@azure/msal-node');
const entraConfig = require('./entraConfig');
const jwt = require('jsonwebtoken');
const multer = require('multer');
const path = require('path');
const fs = require('fs');
const PORT = 9000;

app.use(cors())
app.use(express.json());
app.use(express.static(path.join(__dirname, 'frontend/dist')));


const upload = multer({
    dest: './temp_uploads/',
    limits: {
        filesize: 100 * 1024 * 1024
    }
});

if (!fs.existsSync('./temp_uploads')) {
    fs.mkdirSync('./temp_uploads');
}
if (!fs.existsSync('./media')) {
    fs.mkdirSync('./media');
}

initDb().then(() => {

    app.get('/', (req, res) => {
        res.json({ message: 'Server is running' });
    });

    app.get('/api/articles', authenticateToken, (req, res) => {
        try {
            const articles = getAllArticles();

            articles.forEach(article => {
                article.categories = getArticleCategories(article.id);
                article.tags = getArticleTags(article.id);
            });

            res.json(articles);
        } catch (error) {
            console.error('Error fetching articles:', error);
            res.status(500).json({ error: 'Failed to fetch articles', 'details': String(error) });
        }
    });

    app.get('/api/articles/drafts', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const drafts = getOwnedDrafts(req.user.display_name);
            res.json(drafts);
        } catch (error) {
            console.error('Error fetching owned drafts', error);
            res.status(500).json({ error: 'Failed to fetch owned drafts', details: String(error) });
        }
    });

    app.get('/api/articles/:ka_number', authenticateToken, (req, res) => {
        try {
            const article = getArticle(req.params.ka_number);

            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            article.categories = getArticleCategories(article.id);
            article.tags = getArticleTags(article.id);

            res.json(article);
        } catch (error) {
            console.error('Error fetching article:', error);
            res.status(500).json({ error: 'Failed to fetch article', 'details': String(error) });
        }
    });

    app.post('/api/articles', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const { title, content, status } = req.body;

            if (!title && status === 'published') {
                return res.status(400).json({ error: 'Title is required' });
            }

            const article = createArticle(title, content, req.user.display_name, status);
            res.status(201).json(article);

        } catch (error) {
            console.error('Error creating article:', error);
            res.status(500).json({ error: 'Failed to create article', 'details': String(error) });
        }
    });

    app.put('/api/articles/:ka_number', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const { title, content, status } = req.body;

            if (status && !['draft', 'published'].includes(status)) {
                return res.status(400).json({ error: 'Invalid publishing status' });
            }

            if (status === 'published' && !title) {
                return res.status(400).json({ error: 'Title is required to publish article' });
            }

            const article = updateArticle(
                req.params.ka_number,
                title,
                content,
                req.user.display_name,
                status || 'published'
            );

            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            res.json(article);
        } catch (error) {
            console.error('Error updating article:', error);
            return res.status(500).json({ error: 'Error while updating article', 'details': String(error) });
        }
    });

    app.delete('/api/articles/:ka_number', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            deleteArticle(req.params.ka_number);
            return res.status(200).json({ 'message': 'Successfully deleted article' });

        } catch (error) {
            console.error('Error when deleting article:', error);
            return res.status(500).json({ error: 'Failed to delete article', 'details': String(error) });
        }
    });

    app.get('/api/search', authenticateToken, (req, res) => {
        try {
            const query = req.query.q;

            if (!query) {
                return res.status(400).json({ error: 'Search query is required' });
            }

            const results = searchArticles(query);

            results.forEach(article => {
                article.categories = getArticleCategories(article.id);
                article.tags = getArticleTags(article.id);
            });

            res.json(results);
        } catch (error) {
            console.error('Error when searching articles:', error);
            return res.status(500).json({ error: 'Failed to search articles', 'details': String(error) });
        }
    });

    app.get('/api/search/advanced', authenticateToken, (req, res) => {
        try {
            const { query, categories, tags } = req.query;

            let articles = getAllArticles();

            articles.forEach(article => {
                article.categories = getArticleCategories(article.id);
                article.tags = getArticleTags(article.id);
            });

            if (query) {
                const searchTerm = query.toLowerCase();
                articles = articles.filter(article =>
                    article.title.toLowerCase().includes(searchTerm) ||
                    article.content.toLowerCase().includes(searchTerm) ||
                    article.ka_number.toLowerCase().includes(searchTerm)
                );
            }

            if (categories) {
                const categoryList = categories.split(',').map(c => c.trim().toLowerCase());
                articles = articles.filter(article =>
                    article.categories.some(cat => categoryList.includes(cat.toLowerCase()))
                );
            }

            if (tags) {
                const tagList = tags.split(',').map(t => t.trim().toLowerCase());
                articles = articles.filter(article =>
                    article.tags.some(tag => tagList.includes(tag.toLowerCase()))
                );
            }

            res.json(articles);
        } catch (error) {
            console.error('Error searching articles:', error);
            res.status(500).json({ error: 'Failed to search articles', details: String(error) });
        }
    });

    app.post('/api/auth/register', async (req, res) => {
        try {
            const { username, email, password, display_name } = req.body;

            if (!username || !email || !password || !display_name) {
                return res.status(400).json({ error: 'Username, email, password, and display name are required' });
            }

            const cur_user_username = getUserByUsername(username);
            if (cur_user_username) {
                return res.status(400).json({ error: 'Username already exists' });
            }

            const cur_user_email = getUserByEmail(email);
            if (cur_user_email) {
                return res.status(400).json({ error: 'email address already in use' });
            }

            const pass_hash = await argon2.hash(password);
            const newUser = createUser(username, email, pass_hash, display_name);
            const token = generateToken(newUser);

            return res.status(201).json({
                user: {
                    id: newUser.id,
                    username: newUser.username,
                    email: newUser.email,
                    display_name: newUser.display_name,
                    auth_provider: newUser.auth_provider,
                    role: newUser.role,
                    created_at: newUser.created_at
                },
                token
            });

        } catch (error) {
            console.error('Error when registering new user: ', error);
            return res.status(500).json({ error: 'Failed to create user', 'details': String(error) });
        }
    });

    app.post('/api/auth/login', async (req, res) => {
        try {
            const { username, email, password } = req.body;

            if (!password || (!username && !email)) {
                return res.status(400).json({ error: 'Username/email & password are required' });
            }

            let user;
            if (!username) {
                user = getUserByEmail(email);
            } else {
                user = getUserByUsername(username);
            }

            if (!user || !await argon2.verify(user.pass_hash, password)) {
                return res.status(401).json({ error: 'Invalid credentials' });
            }

            const token = generateToken(user);

            return res.status(200).json({
                user: {
                    id: user.id,
                    username: user.username,
                    email: user.email,
                    display_name: user.display_name,
                    auth_provider: user.auth_provider,
                    role: user.role,
                    created_at: user.created_at
                },
                token
            });
        } catch (error) {
            console.log('Failed to log user in:', error);
            return res.status(500).json({ error: 'Failed to login', 'details': String(error) });
        }
    });

    app.post('/api/auth/microsoft', async (req, res) => {
        try {
            const { accessToken, idToken } = req.body;

            if (!accessToken) {
                return res.status(400).json({ error: 'Access token required' });
            }

            // Get user info directly from Microsoft Graph using the access token
            const graphResponse = await fetch('https://graph.microsoft.com/v1.0/me', {
                headers: {
                    'Authorization': `Bearer ${accessToken}`
                }
            });

            if (!graphResponse.ok) {
                return res.status(401).json({ error: 'Invalid Microsoft token' });
            }

            const decoded = jwt.decode(idToken);
            const roles = decoded.roles || [];
            let userRole = 'User';

            if (roles.includes('Admin')) userRole = 'Admin';
            else if (roles.includes('Editor')) userRole = 'Editor';

            const msUser = await graphResponse.json();

            // Check if user exists in our database
            let user = getUserByEmail(msUser.mail || msUser.userPrincipalName);

            if (!user) {
                // JIT Provisioning - Create new user
                user = createUser(
                    null,
                    msUser.mail || msUser.userPrincipalName,
                    null,
                    msUser.displayName,
                    'entra',
                    msUser.id,
                    userRole
                );
            } else if (user.auth_provider === 'local') {
                return res.status(400).json({
                    error: 'This email is registered with a local account. Please login with username/password.'
                });
            }

            const token = generateToken(user);

            return res.status(200).json({
                user: {
                    id: user.id,
                    username: user.username,
                    email: user.email,
                    display_name: user.display_name,
                    auth_provider: user.auth_provider,
                    role: user.role,
                    created_at: user.created_at
                },
                token
            });
        } catch (err) {
            console.error('Microsoft auth error:', err);
            return res.status(500).json({
                error: 'Microsoft authentication failed',
                details: String(err)
            });
        }
    });

    app.get('/api/admin/users', authenticateToken, authorizeRoles('Admin'), (req, res) => {
        try {
            const users = getAllUsers();
            res.status(200).json(users);
        } catch (error) {
            console.error('Error fetching users:', error);
            res.status(500).json({ error: 'Failed to fetch users', details: String(error) });
        }
    });

    app.put('/api/admin/users/:id/role', authenticateToken, authorizeRoles('Admin'), (req, res) => {
        try {
            const userId = parseInt(req.params.id);
            const { role } = req.body;

            if (!['Admin', 'Editor', 'User'].includes(role)) {
                return res.status(400).json({ error: 'Invalid role. Must be Admin, Editor, or User' });
            }

            if (userId === req.user.id) {
                return res.status(400).json({ error: 'You cannot change your own role' });
            }

            const user = getUserById(userId);
            if (!user) {
                return res.status(404).json({ error: 'User not found' });
            }

            const updatedUser = updateUserRole(userId, role);
            res.status(200).json(updatedUser);
        } catch (error) {
            console.error('Error updating user:', error);
            return res.status(500).json({ error: 'Failed to update user role', details: String(error) });
        }
    });

    app.delete('/api/admin/users/:id', authenticateToken, authorizeRoles('Admin'), (req, res) => {
        try {
            const userId = parseInt(req.params.id);

            if (userId === req.user.id) {
                return res.status(400).json({ error: 'You cannot delete your own user profile' });
            }

            const user = getUserById(userId);
            if (!user) return res.status(404).json({ error: 'User not found' });

            deleteUser(userId);
            return res.status(200).json({ message: 'User deleted successfully' });
        } catch (error) {
            console.error('Error deleting user:', error);
            return res.status(500).json({ error: 'Failed to delete user', details: String(error) });
        }
    });

    app.post('/api/articles/:ka_number/media',
        authenticateToken,
        authorizeRoles('Admin', 'Editor'),
        upload.single('file'),
        async (req, res) => {
            try {
                const kaNumber = req.params.ka_number;
                const file = req.file;

                if (!file) {
                    return res.status(400).json({ error: 'No file uploaded' });
                }

                const article = getArticle(kaNumber);
                if (!article) {
                    fs.unlinkSync(file.path);
                    return res.status(404).json({ error: 'Article not found' });
                }

                const mediaDir = path.join('./media', kaNumber);
                if (!fs.existsSync(mediaDir)) {
                    fs.mkdirSync(mediaDir, { recursive: true });
                }

                const fileExt = path.extname(file.originalname).toLowerCase();
                const isImage = ['.jpg', '.jpeg', '.png', '.gif', '.webp'].includes(fileExt);
                const isVideo = ['.mp4', '.mov', '.avi', '.mkv', '.webm'].includes(fileExt);

                if (!isImage && !isVideo) {
                    fs.unlinkSync(file.path);
                    return res.status(400).json({ error: 'Invalid file type. Only images and videos are allowed.' })
                }

                const timestamp = Date.now();
                const outputFilename = isVideo
                    ? `video_${timestamp}${fileExt}`
                    : `image_${timestamp}${fileExt}`
                const outputPath = path.join(mediaDir, outputFilename);

                fs.renameSync(file.path, outputPath);

                res.json({
                    success: true,
                    filename: outputFilename,
                    url: `/media/${kaNumber}/${outputFilename}`,
                    type: isVideo ? 'video' : 'image'
                });
            } catch (error) {
                console.error('Error uploading media:', error);
                res.status(500).json({ error: 'Failed to upload media', details: String(error) });
            }
        }
    );

    app.get('/api/articles/:ka_number/media', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const kaNumber = req.params.ka_number;
            const mediaDir = path.join('./media', kaNumber);

            if (!fs.existsSync(mediaDir)) {
                return res.json([]);
            }

            const files = fs.readdirSync(mediaDir);
            const mediaList = files.map(filename => {
                const fileExt = path.extname(filename).toLocaleLowerCase();
                const isVideo = ['.mp4', '.mov', '.avi', '.mkv', '.webm'].includes(fileExt);

                return {
                    filename: filename,
                    url: `/media/${kaNumber}/${filename}`,
                    type: isVideo ? 'video' : 'image'
                };
            });

            res.json(mediaList);
        } catch (error) {
            console.error('Error fetching media:', error);
            res.status(500).json({ error: 'Failed to fetch media', details: String(error) });
        }
    });

    app.delete('/api/articles/:ka_number/media/:filename',
        authenticateToken,
        authorizeRoles('Admin', 'Editor'),
        (req, res) => {
            try {
                const { ka_number, filename } = req.params;
                const filePath = path.join('./media', ka_number, filename);

                if (!fs.existsSync(filePath)) {
                    return res.status(404).json({ error: 'File not found' });
                }

                fs.unlinkSync(filePath);
                res.json({ message: 'File deleted successfully' });
            } catch (error) {
                console.error('Error when deleting file:', error);
                res.status(500).json({ error: 'Failed to delete file', details: String(error) });
            }
        }
    );

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

    app.get('/api/categories', authenticateToken, (req, res) => {
        try {
            const categories = getAllCategories();
            res.json(categories);
        } catch (error) {
            console.error('Error fetching categories:', error);
            res.status(500).json({ error: 'Failed to fetch categories', details: String(error) });
        }
    });

    app.post('/api/categories', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const { name } = req.body;

            if (!name || !name.trim()) {
                return res.status(400).json({ error: 'Category name is required' });
            }

            const category = getOrCreateCategory(name.trim());
            res.status(201).json(category);
        } catch (error) {
            console.error('Error creating category:', error);
            res.status(500).json({ error: 'Failed to create category', details: String(error) });
        }
    });


    app.get('/api/tags', authenticateToken, (req, res) => {
        try {
            const tags = getAllTags();
            res.json(tags);
        } catch (error) {
            console.error('Error fetching tags:', error);
            res.status(500).json({ error: 'Failed to fetch tags', details: String(error) });
        }
    });

    app.post('/api/tags', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const { name } = req.body;

            if (!name || !name.trim()) {
                return res.status(400).json({ error: 'Tag name is required' });
            }

            const tag = getOrCreateTag(name.trim());
            res.status(201).json(tag);
        } catch (error) {
            console.error('Error creating tag:', error);
            res.status(500).json({ error: 'Failed to create tag', details: String(error) });
        }
    });

    app.put('/api/articles/:ka_number/categories', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const kaNumber = req.params.ka_number;
            const { categories } = req.body;

            if (!Array.isArray(categories)) {
                return res.status(400).json({ error: 'Categories must be an array' });
            }

            const article = getArticle(kaNumber);
            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            setArticleCategories(article.id, categories);
            res.json({ message: 'Categories updated successfully', categories });
        } catch (error) {
            console.error('Error updating article categories:', error);
            res.status(500).json({ error: 'Failed to update categories', details: String(error) });
        }
    });

    app.put('/api/articles/:ka_number/tags', authenticateToken, authorizeRoles('Admin', 'Editor'), (req, res) => {
        try {
            const kaNumber = req.params.ka_number;
            const { tags } = req.body;

            if (!Array.isArray(tags)) {
                return res.status(400).json({ error: 'Tags must be an array' });
            }

            const article = getArticle(kaNumber);
            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            setArticleTags(article.id, tags);
            res.json({ message: 'Tags updated successfully', tags });
        } catch (error) {
            console.error('Error updating article tags:', error);
            res.status(500).json({ error: 'Failed to update tags', details: String(error) });
        }
    });

    app.get('/api/articles/:ka_number/categories', authenticateToken, (req, res) => {
        try {
            const article = getArticle(req.params.ka_number);

            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            const categories = getArticleCategories(article.id);
            res.json(categories);
        } catch (error) {
            console.error('Error fetching article categories:', error);
            res.status(500).json({ error: 'Failed to fetch categories', details: String(error) });
        }
    });

    app.get('/api/articles/:ka_number/tags', authenticateToken, (req, res) => {
        try {
            const article = getArticle(req.params.ka_number);

            if (!article) {
                return res.status(404).json({ error: 'Article not found' });
            }

            const tags = getArticleTags(article.id);
            res.json(tags);
        } catch (error) {
            console.error('Error fetching article tags:', error);
            res.status(500).json({ error: 'Failed to fetch tags', details: String(error) });
        }
    });

    
    app.use('/media', express.static(path.join(__dirname, 'media')));
    app.listen(PORT, () => {
        console.log(`Server listening on ${PORT}`);
    });
}).catch(err => {
    console.error('Failed to initialize database:', err);
});