from Ars.core import db
from bson import ObjectId
from fastapi import HTTPException
from typing import Optional, List
from motor.motor_asyncio import AsyncIOMotorDatabase
from Ars.objects import UserResilienceScoreCreate, UserResilienceScoreOut,BreakDownByDomainCreate,BreakDownByDomainOut,FlaggedRiskAreasCreate,FlaggedRiskAreasOut,BoostSuggestionsCreate,BoostSuggestionsOut,BoostSuggestionsUpdate,UserResilienceScoreUpdate,FlaggedRiskAreasUpdate,BreakDownByDomainUpdate
import pymongo

async def create_new_hashed_doc_entry(data: dict):
    
    try:
        # Attempt to insert the document, ensuring hashed_doc is unique due to the index
        result = await db.resume_resilience_analysis.insert_one(document=data)
        return {"inserted_id": result.inserted_id,"error":None}  # Return the inserted ID
    except pymongo.errors.DuplicateKeyError:
        # Handle the case where a document with the same 'hashed_doc' already exists
        return {"error": "Document with this 'hashed_doc' already exists"}
    except Exception as e:
        # Catch other exceptions (e.g., database connection issues)
        return {"error": str(e)}
    
async def get_document_by_hashed_doc(hashed_doc: str):
    try:
        # Find the document using the hashed_doc field
        document = await db.resume_resilience_analysis.find_one({"hashed_doc": hashed_doc})
        
        if document:
            return document['resume']
        else:
            return None
    
    except Exception as e:
        # Handle any other errors, like database issues
        return {"error": str(e)}
    
async def get_document_by_hashed_doc_complete(hashed_doc: str):
    try:
        # Find the document using the hashed_doc field
        document = await db.resume_resilience_analysis.find_one({"hashed_doc": hashed_doc})
        
        if document:
            return document
        else:
            return None
    
    except Exception as e:
        # Handle any other errors, like database issues
        return {"error": str(e)}


async def get_document_by_userId(userId: str):
    try:
        # Find the document using the hashed_doc field
        document = await db.resume_resilience_analysis.find_one({"userId": userId})
        
        if document:
            return document['resume']
        else:
            return None
    
    except Exception as e:
        # Handle any other errors, like database issues
        return {"error": str(e)}
    
    
async def create_user_resilience(  data: UserResilienceScoreCreate) -> UserResilienceScoreOut:
    """
    Create a new UserResilienceScore in the database.

    Args:
        db: The MongoDB database instance.
        data: A Pydantic object containing the fields to create.

    Returns:
        The newly created object.
    """
    result = await db.user_resilience.insert_one(data.model_dump())
    created = await db.user_resilience.find_one({"_id": result.inserted_id})
    out = UserResilienceScoreOut(**created)
    return out


async def get_user_resilience(  object_id: str) -> Optional[UserResilienceScoreOut]:
    """
    Retrieve a UserResilienceScore by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to retrieve.

    Returns:
        An bject, or raises 404 if not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.user_resilience.find_one({"_id": ObjectId(object_id)})
    
    if result is None:
        raise HTTPException(status_code=404, detail="Object not found")
    out =UserResilienceScoreOut(**result)
    return out


async def update_user_resilience(  object_id: str, data: UserResilienceScoreUpdate) -> UserResilienceScoreOut:
    """
    Update a UserResilienceScore by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to update.
        data: A Pydantic object with the updated fields.

    Returns:
        The updated object dictionary.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    update_data = {k: v for k, v in data.dict().items() if v is not None}
    result = await db.user_resilience.update_one(
        {"_id": ObjectId(object_id)},
        {"$set": update_data}
    )

    if result.matched_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    updateresult =await db.user_resilience.find_one({"_id": ObjectId(object_id)})
    out = UserResilienceScoreOut(**updateresult)
    return out
    


async def delete_user_resilience(  object_id: str) -> dict:
    """
    Delete a UserResilienceScore by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to delete.

    Returns:
        A confirmation message or raises 404 if object is not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.user_resilience.delete_one({"_id": ObjectId(object_id)})

    if result.deleted_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    return {"message": "Object deleted successfully"}



















async def create_breakdown_by_domain(  data:  BreakDownByDomainCreate) ->  BreakDownByDomainOut:
    """
    Create a new  BreakDownByDomain in the database.

    Args:
        db: The MongoDB database instance.
        data: A Pydantic object containing the fields to create.

    Returns:
        A dictionary representing the newly created object.
    """
    result = await db.breakdown_by_domain.insert_one(data.dict())
    created = await db.breakdown_by_domain.find_one({"_id": result.inserted_id})
    out =  BreakDownByDomainOut(**created)
    return out


async def get_breakdown_by_domain(  object_id: str) -> Optional[ BreakDownByDomainOut]:
    """
    Retrieve a  BreakDownByDomain by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to retrieve.

    Returns:
        A dictionary of the found object, or raises 404 if not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.breakdown_by_domain.find_one({"_id": ObjectId(object_id)})
    
    if result is None:
        raise HTTPException(status_code=404, detail="Object not found")
    out = BreakDownByDomainOut(**result)
    return out


async def update_breakdown_by_domain(  object_id: str, data:  BreakDownByDomainUpdate) ->  BreakDownByDomainOut:
    """
    Update a  BreakDownByDomain by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to update.
        data: A Pydantic object with the updated fields.

    Returns:
        The updated object dictionary.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    update_data = {k: v for k, v in data.dict().items() if v is not None}
    result = await db.breakdown_by_domain.update_one(
        {"_id": ObjectId(object_id)},
        {"$set": update_data}
    )

    if result.matched_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    updateresult =await db. breakdown_by_domain.find_one({"_id": ObjectId(object_id)})
    out =  BreakDownByDomainOut(**updateresult)
    return out
    


async def delete_breakdown_by_domain(  object_id: str) -> dict:
    """
    Delete a  BreakDownByDomain by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to delete.

    Returns:
        A confirmation message or raises 404 if object is not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.breakdown_by_domain.delete_one({"_id": ObjectId(object_id)})

    if result.deleted_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    return {"message": "Object deleted successfully"}









async def create_flagged_risk_areas(  data:  FlaggedRiskAreasCreate) ->  FlaggedRiskAreasOut:
    """
    Create a new  BreakDownByDomain in the database.

    Args:
        db: The MongoDB database instance.
        data: A Pydantic object containing the fields to create.

    Returns:
        A dictionary representing the newly created object.
    """
    result = await db.flagged_risk_areas.insert_one(data.dict())
    created = await db.flagged_risk_areas.find_one({"_id": result.inserted_id})
    out = FlaggedRiskAreasOut(**created)
    return out


async def get_flagged_risk_areas(  object_id: str) -> Optional[FlaggedRiskAreasOut]:
    """
    Retrieve a FlaggedRiskAreas by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to retrieve.

    Returns:
        A dictionary of the found object, or raises 404 if not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.flagged_risk_areas.find_one({"_id": ObjectId(object_id)})
    
    if result is None:
        raise HTTPException(status_code=404, detail="Object not found")
    out =FlaggedRiskAreasOut(**result)
    return out


async def update_flagged_risk_areas(  object_id: str, data: FlaggedRiskAreasUpdate) -> FlaggedRiskAreasOut:
    """
    Update a FlaggedRiskAreas by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to update.
        data: A Pydantic object with the updated fields.

    Returns:
        The updated object dictionary.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    update_data = {k: v for k, v in data.dict().items() if v is not None}
    result = await db.flagged_risk_areas.update_one(
        {"_id": ObjectId(object_id)},
        {"$set": update_data}
    )

    if result.matched_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    updateresult =await db.flagged_risk_areas.find_one({"_id": ObjectId(object_id)})
    out = FlaggedRiskAreasOut(**updateresult)
    return out
    


async def delete_flagged_risk_areas(  object_id: str) -> dict:
    """
    Delete a FlaggedRiskAreas by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to delete.

    Returns:
        A confirmation message or raises 404 if object is not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.flagged_risk_areas.delete_one({"_id": ObjectId(object_id)})

    if result.deleted_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    return {"message": "Object deleted successfully"}















async def create_boost_suggestions(  data: BoostSuggestionsCreate) -> BoostSuggestionsOut:
    """
    Create a new BoostSuggestions in the database.

    Args:
        db: The MongoDB database instance.
        data: A Pydantic object containing the fields to create.

    Returns:
        A dictionary representing the newly created object.
    """
    result = await db.boost_suggestions.insert_one(data.dict())
    created = await db.boost_suggestions.find_one({"_id": result.inserted_id})
    out = BoostSuggestionsOut(**created)
    return out


async def get_boost_suggestions(  object_id: str) -> Optional[BoostSuggestionsOut]:
    """
    Retrieve a BoostSuggestions by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to retrieve.

    Returns:
        A dictionary of the found object, or raises 404 if not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.boost_suggestions.find_one({"_id": ObjectId(object_id)})
    
    if result is None:
        raise HTTPException(status_code=404, detail="Object not found")
    out =BoostSuggestionsOut(**result)
    return out


async def update_boost_suggestions(  object_id: str, data: BoostSuggestionsUpdate) -> BoostSuggestionsOut:
    """
    Update a BoostSuggestions by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to update.
        data: A Pydantic object with the updated fields.

    Returns:
        The updated object dictionary.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    update_data = {k: v for k, v in data.dict().items() if v is not None}
    result = await db.boost_suggestions.update_one(
        {"_id": ObjectId(object_id)},
        {"$set": update_data}
    )

    if result.matched_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    updateresult =await db.boost_suggestions.find_one({"_id": ObjectId(object_id)})
    out = BoostSuggestionsOut(**updateresult)
    return out
    


async def delete_boost_suggestions(  object_id: str) -> dict:
    """
    Delete a BoostSuggestions by its ID.

    Args:
        db: The MongoDB database instance.
        object_id: The ID of the object to delete.

    Returns:
        A confirmation message or raises 404 if object is not found.
    """
    if not ObjectId.is_valid(object_id):
        raise HTTPException(status_code=400, detail="Invalid ID format")

    result = await db.boost_suggestions.delete_one({"_id": ObjectId(object_id)})

    if result.deleted_count == 0:
        raise HTTPException(status_code=404, detail="Object not found")

    return {"message": "Object deleted successfully"}