import axios from 'axios';
import { Request, Response } from 'express';
import { User } from '../models/User';
import { RoleMaster } from '../models/role_master';
import db from '../models';

const UserModel = db.User;
const RoleMasterModel = db.RoleMaster; // Changed from RoleModel to RoleMasterModel
import { Op, ModelStatic, Sequelize } from 'sequelize';
import { generateToken } from '../helpers/generateTokens';
import config from '../config/config';

const env = process.env.NODE_ENV || 'development';

// Add this before your query
export const userSignIn = async (req: Request, res: Response): Promise<any> => {
    try {
        const { token } = req.body;

        if (!process.env.GRAPH_API_ENDPOINT) {
            throw new Error('Graph API endpoint not configured');
        }

        const tokenResponse = await axios.get(process.env.GRAPH_API_ENDPOINT, {
            headers: { 
                'Authorization': `Bearer ${token}`,
                'Content-Type': 'application/json'
            },
        });

        if (!tokenResponse.data.mail) {
            return res.status(400).json({
                success: false,
                message: 'Email not found in token response'
            });
        }

        console.log("tokenResponse");
        // console.log(tokenResponse.data);

        let user = await UserModel.findOne({
            where: { email: tokenResponse.data.mail },
            attributes: ['id', 'first_name', 'last_name', 'email', 'isActive', 'mobile', 'role_id'],
            include: [{
                model: RoleMasterModel,
                required: false,
                attributes: ['id', 'role']
            }],
            nest: true
        });
        console.log(user,"tokenResponse1111");
        const userWithRole = user?.get({ plain: true });

        // if (!user) {
        //     user = await UserModel.create({
        //         email: tokenResponse.data.mail,
        //         first_name: tokenResponse.data.surname,
        //         last_name: tokenResponse.data.givenName,
        //         mobile: tokenResponse.data.mobile,
        //     });
        // }

        if (!user) {
            return res.status(400).json({
                success: false,
                message: 'User not found.',
            });
        }

        if (user.isActive === false) {
            return res.status(400).json({
                success: false,
                msg: 'Your account has been deactivated. Please contact the administrator',
            });
        }

        user = await UserModel.findOne({
            where: { email: tokenResponse.data.mail },
            attributes: [
                'id',
                'first_name',
                'last_name',
                'email',
                'role_id'
            ],
          
        });
        
        // Add debug logging
        // console.log('Raw user object:', JSON.stringify(user, null, 2));

        const userJson = user?.toJSON();
        if (!userJson) {
            return res.status(400).json({ success: false, message: 'User not found or invalid.' });
        }
        const accessToken = await generateToken(userJson);
        console.log('111');
        //update token against user
        await UserModel.update(
            { token: accessToken },
            { where: { id: userJson.id } }
        );


        return res.status(200).json({
            success: true,
            message: `Welcome, ${user?.first_name || 'User'}! Your tasks await your magic touch.`,
            accessToken,
            user_details: userWithRole,
        });
    } catch (err: any) {
        console.error('Auth Error:', err.response?.data || err.message);
        return res.status(400).json({ 
            success: false, 
            message: err.response?.data?.message || err.message 
        });
    }
};

//Create logout API
export const userSignOut = async (req: Request, res: Response): Promise<any> => {
    try {
        const userId = req.body.email; // Assuming you are sending userId in the request body
        console.log("userId",userId);
        // update the user table token null based on email
        await UserModel.update(
            { token: "" },
            { where: { email: userId } }
        );
        //Get the users
        const user = await UserModel.findOne({
            where: { email: userId },
            attributes: ['id', 'first_name', 'last_name', 'email', 'isActive', 'mobile', 'role_id'],
        });
        if (!userId) {
            return res.status(400).json({
                success: false,
                message: 'User ID is required for logout',
            });
        }
        return res.status(200).json({
            success: true,
            message: `See you soon, ${user?.first_name || 'User'}! We'll keep your momentum going.`,

        });
    } catch (err:any) {
        console.error('Logout Error:', err);
        return res.status(400).json({ 
            success: false, 
            message: err.message 
        });
    }
};