from flask import Blueprint, request, jsonify
from app.core import client
from app.database.vector_embedings.load_pdf    import load_pdf
from app.database.vector_embedings.split_and_store import split_and_store
from app.database.fetch_data import get_character_by_id, update_character_by_id, get_characters_by_client_id
from datetime import datetime
import uuid
from bson import ObjectId

character_bp = Blueprint("character", __name__, url_prefix="/api")

@character_bp.route("/create-character", methods=["POST"])
def create_character():
    data = request.get_json()
    try:
        db = client['character_test']
        collection = db['character_descriptions']
        # If client_id is present and non-empty, store as private character
        if data.get('client_id'):
            result = collection.insert_one(data)
            return jsonify({"success": True, "type": "private", "insertedId": str(result.inserted_id)})
        else:
            # Remove client_id if present but empty or null
            data.pop('client_id', None)
            result = collection.insert_one(data)
            return jsonify({"success": True, "type": "public", "insertedId": str(result.inserted_id)})
    except Exception as err:
        return jsonify({"success": False, "error": str(err)}), 500

@character_bp.route("/delete-character", methods=["DELETE"])
def delete_character():
    character_id = request.args.get('character_id')
    if not character_id:
        return jsonify({"error": "character_id is required"}), 400
    try:
        db = client['character_test']
        character_collection = db['character_descriptions']
        result = character_collection.delete_one({"character_id": character_id})
        if result.deleted_count == 0:
            return jsonify({"error": "Character not found"}), 404
        # Delete from related collections
        narrative_db = client['narrative_design_test']
        narrative_db['mannual_triggers'].delete_many({"character_id": character_id})
        narrative_db['sections'].delete_many({"character_id": character_id})
        narrative_db['triggers'].delete_many({"character_id": character_id})
        save_nodes_db = client['save_nodes']
        save_nodes_db['details'].delete_many({"character_id": character_id})
        return jsonify({"message": "Character and related details deleted successfully"}), 200
    except Exception as error:
        return jsonify({"error": str(error)}), 500

@character_bp.route("/get-character", methods=["GET"])
def get_character():
    character_id = request.args.get('character_id')
    if not character_id:
        return jsonify({"error": "character_id is required"}), 400
    try:
        db = client['character_test']
        collection = db['character_descriptions']
        character = collection.find_one({"character_id": character_id})
        if not character:
            return jsonify({"error": "Character not found"}), 404
        character['_id'] = str(character['_id'])
        return jsonify(character)
    except Exception as error:
        return jsonify({"error": str(error)}), 500

@character_bp.route("/recent-characters", methods=["GET"])
def get_recent_characters():
    try:
        db = client['character_test']
        collection = db['character_descriptions']
        recent_characters = list(collection.find().sort([('_id', -1)]).limit(20))
        for char in recent_characters:
            char['_id'] = str(char['_id'])
        return jsonify(recent_characters)
    except Exception as err:
        return jsonify({"success": False, "error": str(err)})

@character_bp.route("/save-character", methods=["PUT"])
def save_character():
    data = request.get_json()
    character_id = data.get('character_id')
    if not character_id:
        return jsonify({"error": "character_id is required"}), 400
    try:
        db = client['character_test']
        collection = db['character_descriptions']
        result = collection.find_one_and_update(
            {"character_id": character_id},
            {"$set": data},
            return_document=True
        )
        if not result:
            return jsonify({"error": "Character not found"}), 404
        result['_id'] = str(result['_id'])
        return jsonify({"success": True, "response": result})
    except Exception as error:
        return jsonify({"success": False, "error": str(error)}), 500

@character_bp.route("/client/<client_id>/characters", methods=["GET"])
def get_client_characters(client_id):
    """Get all characters for a specific client."""
    try:
        characters = get_characters_by_client_id(client_id)
        return jsonify({
            "success": True,
            "characters": characters
        })
    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500

@character_bp.route("/upload", methods=["POST"])
def upload_pdf():
    file = request.files.get("file")
    character_id = request.form.get("character_id")
    if not file or not character_id:
        return jsonify(success=False, error="Missing file or character_id"), 400

    try:
        docs = load_pdf(file)
        message = split_and_store(client,docs, character_id)
        return jsonify(success=True, message=message)
    except Exception as e:
        return jsonify(success=False, error=str(e)), 500

@character_bp.route("/<character_id>", methods=["GET"])
def fetch_character(character_id):
    client_id = request.args.get('client_id')  # Make client_id optional for backward compatibility
    try:
        char = get_character_by_id(character_id, client_id)
        return jsonify({"success": True, "character": char})
    except ValueError as e:
        return jsonify({"success": False, "error": str(e)}), 404
    except Exception as e:
        return jsonify({"success": False, "error": str(e)}), 500

@character_bp.route("/update_character/<character_id>", methods=["POST"])
def update_character(character_id):
    data = request.get_json() or {}
    try:
        updated = update_character_by_id(character_id, data)
        return jsonify(success=True, character=updated)
    except Exception as e:
        return jsonify(success=False, error=str(e)), 500

@character_bp.route('/toggle_button', methods=['POST'])
def toggle_button_http():
    """Toggle button state for character via HTTP."""
    data = request.get_json()
    character_id = data.get("character_id")

    if not character_id:
        return jsonify({"error": "Invalid data: character_id missing"}), 400

    character_data = get_character_by_id(character_id)
    updated_state = not bool(character_data[3])
    update_character_by_id(character_id, {"toggle_button": updated_state})

    return jsonify({
        "character_id": character_id,
        "button_enabled": updated_state
    }), 200