from flask import jsonify, request, Blueprint
from flask_login import login_required

from frontend.dashboard import user_manager, event_manager, region_manager, system_manager
from utilities.database import db
from utilities.web_logger import WebLogger

bp_api = Blueprint('api', __name__, url_prefix='/telezab/rest/api')
web_logger = WebLogger(db)


@bp_api.route('/users', methods=['GET', 'POST'])
@login_required
def manage_users():
    if request.method == 'GET':
        page = request.args.get('page', 1, type=int)
        per_page = request.args.get('per_page', 20, type=int)
        return jsonify(user_manager.get_users(page, per_page))
    elif request.method == 'POST':
        user_data = request.get_json()
        try:
            result, status_code = user_manager.add_user(user_data)
            if status_code == 201:
                web_logger.log_web_action(
                    action='Добавление пользователя Telegram',
                    details=f'Telegram ID: {user_data.get("chat_id")}, Username: {user_data.get("username")}'
                )
            return jsonify(result), status_code
        except Exception as e:
            return jsonify({'error': str(e)}), 500

@bp_api.route('/users/<int:chat_id>', methods=['GET'])
@login_required
def get_user(chat_id):
    user = user_manager.get_user(chat_id)
    if not user:
        return jsonify({'error': 'Пользователь не найден'}), 404
    return jsonify(user)


@bp_api.route('/users/<int:chat_id>/block', methods=['POST'])
@login_required
def block_user(chat_id):
    user_info = user_manager.get_user(chat_id)
    blocked = user_manager.toggle_block_user(chat_id)
    if blocked is not None:
        status = 'заблокирован' if blocked else 'разблокирован'
        web_logger.log_web_action(
            action=f'Блокировка/разблокировка пользователя Telegram',
            details=f'Telegram ID: {chat_id}, Username: {user_info.get("username") if user_info else "неизвестно"}, Статус: {status}'
        )
        return jsonify({'status': 'updated', 'new_status': blocked})
    else:
        return jsonify({'status': 'error', 'message': 'User not found'}), 404


@bp_api.route('/users/<int:chat_id>', methods=['DELETE'])
@login_required
def delete_user(chat_id):
    user_info = user_manager.get_user(chat_id)
    if user_manager.delete_user(chat_id):
        web_logger.log_web_action(
            action='Удаление пользователя Telegram',
            details=f'Telegram ID: {chat_id}, Username: {user_info.get("username") if user_info else "неизвестно"}'
        )
        return jsonify({'status': 'deleted'})
    else:
        return jsonify({'status': 'error', 'message': 'User not found'}), 404


@bp_api.route('/users/<int:chat_id>/log', methods=['POST'])
@login_required
def log_user_action(chat_id):
    action = request.json.get('action')
    if action:
        event_manager.log_user_action(chat_id, action)
        return jsonify({'message': 'Действие сохранено'}), 200
    else:
        return jsonify({'error': 'Не указано действие'}), 400

@bp_api.route('/users/search', methods=['GET'])
@login_required
def search_users():
    telegram_id = request.args.get('telegram_id')
    email = request.args.get('email')
    users = user_manager.search_users(telegram_id, email)
    return jsonify(users)

@bp_api.route('/user_events/<int:chat_id>', methods=['GET'])
@login_required
def handle_user_events(chat_id):
    return event_manager.get_user_events(chat_id)



@bp_api.route('/regions', methods=['GET', 'POST', 'PUT', 'DELETE'])
@login_required
def manage_regions():
    if request.method == 'POST':
        region_data = request.get_json()
        result = region_manager.add_region(region_data)
        web_logger.log_web_action(
            action='Добавление региона',
            details=f'Название: {region_data.get("name")}, Номер: {region_data.get("number")}'
        )
        return jsonify(result)
    elif request.method == 'PUT':
        region_data = request.get_json()
        if 'active' in region_data:
            result = region_manager.update_region_status(region_data)
            status = 'активирован' if region_data.get('active') else 'деактивирован'
            web_logger.log_web_action(
                action='Изменение статуса региона',
                details=f'ID: {region_data.get("region_id")}, Статус: {status}'
            )
            return jsonify(result)
        elif 'name' in region_data:
            result = region_manager.update_region_name(region_data)
            web_logger.log_web_action(
                action='Изменение названия региона',
                details=f'ID: {region_data.get("region_id")}, Новое название: {region_data.get("name")}'
            )
            return jsonify(result)
        else:
            return jsonify({'status': 'error', 'message': 'Некорректный запрос'}), 400
    elif request.method == 'DELETE':
        region_id = request.args.get('region_id')
        region_info = region_manager.get_region(region_id)
        result = region_manager.delete_region(region_id)
        if result.get('status') == 'success':
            web_logger.log_web_action(
                action='Удаление региона',
                details=f'ID: {region_id}, Название: {region_info.get("region_name") if region_info else "неизвестно"}'
            )
        return jsonify(result)

@bp_api.route('/regions/<region_id>/subscribers', methods=['GET'])
@login_required
def get_region_subscribers(region_id):
    result, status_code = region_manager.get_region_subscribers(region_id)
    return jsonify(result), status_code

@bp_api.route('/systems', methods=['GET'])
@login_required
def get_systems():
    page = request.args.get('page', 1, type=int)
    per_page = request.args.get('per_page', 10, type=int)
    sort_field = request.args.get('sort_field', 'system_id')
    sort_order = request.args.get('sort_order', 'asc')

    result = system_manager.get_systems(page, per_page, sort_field, sort_order)
    return jsonify(result)

@bp_api.route('/systems', methods=['POST', 'PUT', 'DELETE'])
@login_required
def manage_systems():
    if request.method == 'POST':
        data = request.get_json()
        result, status_code = system_manager.add_system(data)
        if status_code == 201:
            web_logger.log_web_action(
                action='Добавление системы',
                details=f'ID: {data.get("system_id")}, Название: {data.get("name")}'
            )
        return jsonify(result), status_code
    elif request.method == 'PUT':
        data = request.get_json()
        system_info_before = system_manager.get_system(data.get('system_id'))
        result, status_code = system_manager.update_system_name(data)
        if status_code == 200:
            web_logger.log_web_action(
                action='Изменение названия системы',
                details=f'ID: {data.get("system_id")}, Старое название: {system_info_before.get("name") if system_info_before else "неизвестно"}, Новое название: {data.get("name")}'
            )
        return jsonify(result), status_code
    elif request.method == 'DELETE':
        system_id = request.args.get('system_id')
        system_info = system_manager.get_system(system_id)
        result, status_code = system_manager.delete_system(system_id)
        if status_code == 200:
            web_logger.log_web_action(
                action='Удаление системы',
                details=f'ID: {system_id}, Название: {system_info.get("name") if system_info else "неизвестно"}'
            )
        return jsonify(result), status_code

@bp_api.route('/web_logs', methods=['GET'])
@login_required
def get_web_logs():
    page = request.args.get('page', 1, type=int)
    per_page = request.args.get('per_page', 20, type=int)
    ldap_user_id_filter = request.args.get('user_id', None, type=str)
    action_filter = request.args.get('action', None, type=str)

    logs_data = web_logger.get_web_action_logs(page, per_page, ldap_user_id_filter, action_filter)
    return jsonify(logs_data)

#
# @bp_api.route('/systems', methods=['POST'])
# @login_required
# def add_system():
#     data = request.get_json()
#     result, status_code = system_manager.add_system(data)
#     return jsonify(result), status_code
#
# @bp_api.route('/systems', methods=['PUT'])
# @login_required
# def update_system():
#     data = request.get_json()
#     result, status_code = system_manager.update_system_name(data)
#     return jsonify(result), status_code
#
# @bp_api.route('/systems', methods=['DELETE'])
# @login_required
# def delete_system():
#     system_id = request.args.get('system_id')
#     result, status_code = system_manager.delete_system(system_id)
#     return jsonify(result), status_code

@bp_api.route('/debug/log-level', methods=['POST'])
@login_required
def set_log_level():
    from telezab import log_manager
    try:
        data = request.get_json()
        component = data.get('component').lower()
        level = data.get('level').upper()
        success, message = log_manager.change_log_level(component, level)
        if success:
            return jsonify({'status': 'success', 'message': message}), 200
        else:
            return jsonify({'status': 'error', 'message': message}), 400

    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)}), 500


@bp_api.route('/notifications', methods=['POST'])
def notification():
    from utilities.notification_manager import NotificationManager
    from utilities.telegram_utilities import extract_region_number, format_message
    from backend_flask import app
    try:
        data = request.get_json()
        app.logger.info(f"Получены данные уведомления: {data}")
        region_id = extract_region_number(data.get("host"))
        if region_id is None:
            app.logger.error(f"Не удалось извлечь номер региона из host: {data.get('host')}")
            return jsonify({"status": "error", "message": "Invalid host format"}), 400
        app.logger.debug(f"Извлечён номер региона: {region_id}")

        manager = NotificationManager(app.logger)
        subscribers = manager.get_subscribers(region_id, data['severity'])
        if manager.is_region_active(region_id):
            message = format_message(data)
            manager.send_notifications(subscribers, message)

        return jsonify({"status": "success"}), 200

    except Exception as e:
        app.logger.error(f"Ошибка при обработке уведомления: {e}")
        return jsonify({"status": "error", "message": "Внутренняя ошибка сервера"}), 500