import os
import fitz  # PyMuPDF
import spacy
import requests
from recruitment import models
from django.conf import settings

nlp = spacy.load("en_core_web_sm")

def extract_text_from_pdf(pdf_path):
    text = ""
    with fitz.open(pdf_path) as doc:
        for page in doc:
            text += page.get_text()
    return text

def extract_summary_from_pdf(pdf_path):
    if not os.path.exists(pdf_path):
        return {'error': 'File not found'}

    text = extract_text_from_pdf(pdf_path)
    doc = nlp(text)
    summary = {
        'name': doc.ents[0].text if doc.ents else '',
        'skills': [chunk.text for chunk in doc.noun_chunks if len(chunk.text.split()) > 1],
        'summary': text[:500]
    }
    return summary


def dashboard_callback(request, context):
    total_jobs = models.Job.objects.count()
    total_candidates = models.Candidate.objects.count()
    jobs = models.Job.objects.all()
    job_titles = [job.title for job in jobs]
    job_app_counts = [job.candidates.count() for job in jobs]

    context.update({
        "total_jobs": total_jobs,
        "total_candidates": total_candidates,
        "job_titles": job_titles,
        "job_app_counts": job_app_counts,
    })
    return context




def get_access_token():
        """Obtain an access token using server-to-server OAuth."""
        client_id = settings.ZOOM_CLIENT_ID
        client_secret = settings.ZOOM_CLIENT_SECRET

        auth_url = "https://zoom.us/oauth/token"
        headers = {
            "Content-Type": "application/x-www-form-urlencoded",
        }
        data = {
            "grant_type": "account_credentials",
            "account_id": settings.ZOOM_ACCOUNT_ID,
        }

        auth = (client_id, client_secret)

        response = requests.post(auth_url, headers=headers, data=data, auth=auth)

        if response.status_code == 200:
            return response.json().get("access_token")
        else:
            raise Exception(f"Failed to obtain access token: {response.json()}")

def create_zoom_meeting(topic, start_time, duration):
    """
    Create a Zoom meeting using the Zoom API.

    Args:
        topic (str): The topic of the meeting.
        start_time (str): The start time of the meeting in ISO 8601 format (e.g., "2023-10-01T10:00:00Z").
        duration (int): The duration of the meeting in minutes.

    Returns:
        dict: A dictionary containing the meeting details if successful, or an error message if failed.
    """
    try:
        access_token = get_access_token()

        meeting_details = {
            "topic": topic,
            "type": 2,
            "start_time": start_time,
            "duration": duration,
            "timezone": "UTC",
            "settings": {
                "host_video": True,
                "participant_video": True,
                "join_before_host": True,
                "mute_upon_entry": False,
                "approval_type": 2,
                "audio": "both",
                "auto_recording": "none"
            }
        }

        # Make API request to Zoom to create the meeting
        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        response = requests.post(
            "https://api.zoom.us/v2/users/me/meetings",
            headers=headers,
            json=meeting_details
        )

        # Check response status
        if response.status_code == 201:
            meeting_data = response.json()
            return {
                "status": "success",
                "message": "Meeting created successfully.",
                "meeting_details": {
                    "join_url": meeting_data['join_url'],
                    "meeting_id": meeting_data['id'],
                    "password": meeting_data['password'],
                    "host_email": meeting_data['host_email']
                },
                "zoom_gateway_response": meeting_data
            }
        else:
            return {
                "status": "error",
                "message": "Failed to create meeting.",
                "details": response.json()
            }

    except Exception as e:
        return {
            "status": "error",
            "message": str(e)
        }


def list_zoom_meetings(next_page_token=None):
    """
    List all meetings for a user using the Zoom API.

    Args:
        next_page_token (str, optional): The token for paginated results. Defaults to None.

    Returns:
        dict: A dictionary containing the list of meetings or an error message.
    """
    try:
        access_token = get_access_token()
        user_id = 'me'

        params = {}
        if next_page_token:
            params['next_page_token'] = next_page_token

        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        response = requests.get(
            f"https://api.zoom.us/v2/users/{user_id}/meetings",
            headers=headers,
            params=params
        )

        if response.status_code == 200:
            meetings_data = response.json()
            return {
                "status": "success",
                "message": "Meetings retrieved successfully.",
                "meetings": meetings_data.get("meetings", []),
                "next_page_token": meetings_data.get("next_page_token")
            }
        else:
            return {
                "status": "error",
                "message": "Failed to retrieve meetings.",
                "details": response.json()
            }

    except Exception as e:
        return {
            "status": "error",
            "message": str(e)
        }


def get_zoom_meeting_details(meeting_id):
    """
    Retrieve details of a specific meeting using the Zoom API.

    Args:
        meeting_id (str): The ID of the meeting to retrieve.

    Returns:
        dict: A dictionary containing the meeting details or an error message.
    """
    try:
        access_token = get_access_token()

        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        response = requests.get(
            f"https://api.zoom.us/v2/meetings/{meeting_id}",
            headers=headers
        )

        if response.status_code == 200:
            meeting_data = response.json()
            return {
                "status": "success",
                "message": "Meeting details retrieved successfully.",
                "meeting_details": meeting_data
            }
        else:
            return {
                "status": "error",
                "message": "Failed to retrieve meeting details.",
                "details": response.json()
            }

    except Exception as e:
        return {
            "status": "error",
            "message": str(e)
        }


def update_zoom_meeting(meeting_id, updated_data):
    """
    Update a Zoom meeting using the Zoom API.

    Args:
        meeting_id (str): The ID of the meeting to update.
        updated_data (dict): A dictionary containing the fields to update (e.g., topic, start_time, duration).

    Returns:
        dict: A dictionary containing the updated meeting details or an error message.
    """
    try:
        access_token = get_access_token()
        headers = {
            "Authorization": f"Bearer {access_token}",
            "Content-Type": "application/json"
        }
        response = requests.patch(
            f"https://api.zoom.us/v2/meetings/{meeting_id}",
            headers=headers,
            json=updated_data
        )

        if response.status_code == 204:
            return {
                "status": "success",
                "message": "Meeting updated successfully."
            }
        else:
            print(response.json())
            return {
                "status": "error",
                "message": "Failed to update meeting.",
            }

    except Exception as e:
        return {
            "status": "error",
            "message": str(e)
        }


def delete_zoom_meeting(meeting_id):
    """
    Delete a Zoom meeting using the Zoom API.

    Args:
        meeting_id (str): The ID of the meeting to delete.

    Returns:
        dict: A dictionary indicating success or failure.
    """
    try:
        access_token = get_access_token()
        headers = {
            "Authorization": f"Bearer {access_token}"
        }
        response = requests.delete(
            f"https://api.zoom.us/v2/meetings/{meeting_id}",
            headers=headers
        )

        if response.status_code == 204:
            return {
                "status": "success",
                "message": "Meeting deleted successfully."
            }
        else:
            return {
                "status": "error",
                "message": "Failed to delete meeting.",
                "details": response.json()
            }

    except Exception as e:
        return {
            "status": "error",
            "message": str(e)
        }