NeveTimePanel/backend/main.py

from fastapi import FastAPI, WebSocket, UploadFile, File, HTTPException, Depends, status, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import FileResponse, RedirectResponse
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel
import asyncio
import subprocess
import psutil
import os
import shutil
import sys
from pathlib import Path
from typing import Optional
import json
from passlib.context import CryptContext
from jose import JWTError, jwt
from datetime import datetime, timedelta
from authlib.integrations.starlette_client import OAuth
from authlib.common.errors import AuthlibBaseError
import httpx
from dotenv import load_dotenv
from oidc_config import get_enabled_providers, get_redirect_uri, OIDC_PROVIDERS

# Загружаем переменные окружения
load_dotenv()

app = FastAPI(title="MC Panel")

# Инициализация OAuth
oauth = OAuth()

# Регистрация ZITADEL провайдера
enabled_providers = get_enabled_providers()
if "zitadel" in enabled_providers:
    config = enabled_providers["zitadel"]
    oauth.register(
        name="zitadel",
        client_id=config["client_id"],
        client_secret=config["client_secret"],
        server_metadata_url=config["server_metadata_url"],
        client_kwargs={"scope": " ".join(config["scopes"])}
    )
    print(f"✓ ZITADEL провайдер зарегистрирован: {config['issuer']}")
else:
    print("⚠ ZITADEL провайдер не настроен. Проверьте .env файл.")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Настройки безопасности
SECRET_KEY = "your-secret-key-change-this-in-production-12345"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 7  # 7 дней

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
security = HTTPBearer(auto_error=False)

SERVERS_DIR = Path("servers")
SERVERS_DIR.mkdir(exist_ok=True)
USERS_FILE = Path("users.json")
TICKETS_FILE = Path("tickets.json")

server_processes: dict[str, subprocess.Popen] = {}
server_logs: dict[str, list[str]] = {}

IS_WINDOWS = sys.platform == 'win32'

# Инициализация файла пользователей
def init_users():
    if not USERS_FILE.exists():
        admin_user = {
            "username": "Root",
            "password": pwd_context.hash("Admin"),
            "role": "admin",
            "servers": []
        }
        save_users({"Sofa12345": admin_user})
        print("Создан пользователь по умолчанию: none / none")

def load_users() -> dict:
    if USERS_FILE.exists():
        with open(USERS_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    return {}

def save_users(users: dict):
    with open(USERS_FILE, 'w', encoding='utf-8') as f:
        json.dump(users, f, indent=2, ensure_ascii=False)

def load_server_config(server_name: str) -> dict:
    config_path = SERVERS_DIR / server_name / "panel_config.json"
    if config_path.exists():
        with open(config_path, 'r', encoding='utf-8') as f:
            return json.load(f)
    return {
        "name": server_name,
        "displayName": server_name,
        "startCommand": "java -Xmx2G -Xms1G -jar server.jar nogui"
    }

def save_server_config(server_name: str, config: dict):
    config_path = SERVERS_DIR / server_name / "panel_config.json"
    with open(config_path, 'w', encoding='utf-8') as f:
        json.dump(config, f, indent=2, ensure_ascii=False)

# Функции для работы с тикетами
def load_tickets() -> dict:
    if TICKETS_FILE.exists():
        with open(TICKETS_FILE, 'r', encoding='utf-8') as f:
            return json.load(f)
    return {}

def save_tickets(tickets: dict):
    with open(TICKETS_FILE, 'w', encoding='utf-8') as f:
        json.dump(tickets, f, indent=2, ensure_ascii=False)

init_users()

# Функции аутентификации
def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password):
    return pwd_context.hash(password)

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
    if not credentials:
        raise HTTPException(status_code=401, detail="Требуется авторизация")
    
    token = credentials.credentials
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise HTTPException(status_code=401, detail="Неверный токен")
        
        users = load_users()
        if username not in users:
            raise HTTPException(status_code=401, detail="Пользователь не найден")
        
        user = users[username]
        
        # Проверка на бан
        if user.get("role") == "banned":
            raise HTTPException(status_code=403, detail="Ваш аккаунт заблокирован")
        
        return user
    except JWTError:
        raise HTTPException(status_code=401, detail="Неверный токен")

def check_server_access(user: dict, server_name: str):
    # Владелец имеет доступ ко всем серверам
    if user["role"] == "owner":
        return True
    # Админы имеют доступ ко всем серверам
    if user["role"] == "admin":
        return True
    # Проверяем права на серверы
    if not user.get("permissions", {}).get("servers", True):
        return False
    return server_name in user.get("servers", [])

# API для аутентификации

# OpenID Connect endpoints
@app.get("/api/auth/oidc/providers")
async def get_oidc_providers():
    """Получить список доступных OpenID Connect провайдеров"""
    providers = {}
    for provider_id, config in get_enabled_providers().items():
        providers[provider_id] = {
            "name": config["name"],
            "icon": config["icon"],
            "color": config["color"]
        }
    return providers

@app.get("/api/auth/oidc/{provider}/login")
async def oidc_login(provider: str, request: Request):
    """Начать процесс аутентификации через OpenID Connect"""
    if provider not in get_enabled_providers():
        raise HTTPException(404, f"Провайдер {provider} не найден или не настроен")
    
    try:
        redirect_uri = get_redirect_uri(provider, os.getenv("BASE_URL", "http://localhost:8000"))
        return await oauth.create_client(provider).authorize_redirect(request, redirect_uri)
    except Exception as e:
        raise HTTPException(500, f"Ошибка инициализации OAuth: {str(e)}")

@app.get("/api/auth/oidc/{provider}/callback")
async def oidc_callback(provider: str, request: Request):
    """Обработка callback от OpenID Connect провайдера"""
    if provider not in get_enabled_providers():
        raise HTTPException(404, f"Провайдер {provider} не найден или не настроен")
    
    try:
        client = oauth.create_client(provider)
        
        # Получаем токен от провайдера
        token = await client.authorize_access_token(request)
        
        # Получаем данные пользователя
        user_data = token.get("userinfo")
        if not user_data:
            # Если userinfo нет в токене, парсим id_token
            user_data = token.get("id_token")
            if not user_data:
                raise HTTPException(400, "Не удалось получить данные пользователя")
        
        # Создаём или обновляем пользователя
        username = create_or_update_oidc_user(user_data, provider)
        
        # Создаём JWT токен для нашей системы
        users = load_users()
        user = users[username]
        access_token = create_access_token({"sub": username, "role": user["role"]})
        
        # Перенаправляем на фронтенд с токеном
        frontend_url = os.getenv("FRONTEND_URL", "http://localhost:3000")
        return RedirectResponse(f"{frontend_url}/?token={access_token}&username={username}")
        
    except AuthlibBaseError as e:
        print(f"OAuth ошибка для {provider}: {str(e)}")
        raise HTTPException(400, f"OAuth ошибка: {str(e)}")
    except Exception as e:
        print(f"Ошибка аутентификации для {provider}: {str(e)}")
        raise HTTPException(500, f"Ошибка аутентификации: {str(e)}")

def create_or_update_oidc_user(user_data: dict, provider: str) -> str:
    """Создать или обновить пользователя из OpenID Connect данных"""
    users = load_users()
    
    # Генерируем уникальное имя пользователя
    email = user_data.get("email", "")
    name = user_data.get("name", "")
    sub = user_data.get("sub", "")
    
    # Пытаемся использовать email как username
    if email:
        base_username = email.split("@")[0]
    elif name:
        base_username = name.replace(" ", "_").lower()
    else:
        base_username = f"{provider}_user"
    
    # Убираем недопустимые символы
    import re
    base_username = re.sub(r'[^a-zA-Z0-9_-]', '', base_username)
    
    # Ищем существующего пользователя по OIDC ID
    oidc_id = f"{provider}:{sub}"
    existing_user = None
    for username, user_info in users.items():
        if user_info.get("oidc_id") == oidc_id:
            existing_user = username
            break
    
    if existing_user:
        # Обновляем существующего пользователя
        users[existing_user]["email"] = email
        users[existing_user]["name"] = name
        users[existing_user]["picture"] = user_data.get("picture")
        save_users(users)
        return existing_user
    else:
        # Создаём нового пользователя
        username = base_username
        counter = 1
        while username in users:
            username = f"{base_username}_{counter}"
            counter += 1
        
        users[username] = {
            "username": username,
            "password": "",  # Пустой пароль для OIDC пользователей
            "role": "user",
            "servers": [],
            "oidc_id": oidc_id,
            "email": email,
            "name": name,
            "picture": user_data.get("picture"),
            "provider": provider,
            "created_at": datetime.utcnow().isoformat()
        }
        save_users(users)
        return username

@app.post("/api/auth/register")
async def register(data: dict):
    users = load_users()
    username = data.get("username", "").strip()
    password = data.get("password", "").strip()
    
    if not username or not password:
        raise HTTPException(400, "Имя пользователя и пароль обязательны")
    
    if username in users:
        raise HTTPException(400, "Пользователь уже существует")
    
    # Первый пользователь становится владельцем
    role = "owner" if len(users) == 0 else "user"
    
    users[username] = {
        "username": username,
        "password": get_password_hash(password),
        "role": role,
        "servers": [],
        "permissions": {
            "servers": True,
            "tickets": True,
            "users": True if role == "owner" else False,
            "files": True
        } if role == "owner" else {
            "servers": True,
            "tickets": True,
            "users": False,
            "files": True
        }
    }
    
    save_users(users)
    
    access_token = create_access_token(data={"sub": username, "role": role})
    return {
        "access_token": access_token,
        "token_type": "bearer",
        "username": username,
        "role": role
    }

@app.post("/api/auth/login")
async def login(data: dict):
    users = load_users()
    username = data.get("username", "").strip()
    password = data.get("password", "").strip()
    
    if username not in users:
        raise HTTPException(401, "Неверное имя пользователя или пароль")
    
    user = users[username]
    if not verify_password(password, user["password"]):
        raise HTTPException(401, "Неверное имя пользователя или пароль")
    
    access_token = create_access_token(data={"sub": username, "role": user["role"]})
    return {
        "access_token": access_token,
        "token_type": "bearer",
        "username": username,
        "role": user["role"]
    }

@app.get("/api/auth/me")
async def get_me(user: dict = Depends(get_current_user)):
    users = load_users()
    user_data = users.get(user["username"], {})
    
    # Если у пользователя нет прав, создаем дефолтные
    if "permissions" not in user_data:
        user_data["permissions"] = {
            "servers": True,
            "tickets": True,
            "users": user_data["role"] in ["owner", "admin"],
            "files": True
        }
        users[user["username"]] = user_data
        save_users(users)
    
    return {
        "username": user["username"],
        "role": user["role"],
        "servers": user.get("servers", []),
        "permissions": user_data.get("permissions", {})
    }

# API для управления пользователями
@app.get("/api/users")
async def get_users(user: dict = Depends(get_current_user)):
    # Владелец, админы и тех. поддержка видят всех пользователей
    users = load_users()
    return [
        {
            "username": u["username"],
            "role": u["role"],
            "servers": u.get("servers", []),
            "permissions": u.get("permissions", {
                "servers": True,
                "tickets": True,
                "users": u["role"] in ["owner", "admin"],
                "files": True
            })
        }
        for u in users.values()
    ]

@app.put("/api/users/{username}/servers")
async def update_user_servers(username: str, data: dict, user: dict = Depends(get_current_user)):
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    # Админы могут управлять доступом к любым серверам
    if user["role"] == "admin":
        users[username]["servers"] = data.get("servers", [])
        save_users(users)
        return {"message": "Доступ обновлен"}
    
    # Обычные пользователи могут управлять доступом только к своим серверам
    requested_servers = data.get("servers", [])
    current_servers = users[username].get("servers", [])
    
    # Проверяем, что пользователь пытается изменить доступ только к своим серверам
    for server_name in requested_servers:
        if server_name not in current_servers:
            # Проверяем, является ли текущий пользователь владельцем этого сервера
            config = load_server_config(server_name)
            if config.get("owner") != user["username"]:
                raise HTTPException(403, f"Вы не можете выдать доступ к серверу {server_name}")
    
    users[username]["servers"] = requested_servers
    save_users(users)
    return {"message": "Доступ обновлен"}

@app.delete("/api/users/{username}")
async def delete_user(username: str, user: dict = Depends(get_current_user)):
    # Только владелец может удалять пользователей
    if user["role"] != "owner":
        raise HTTPException(403, "Только владелец может удалять пользователей")
    
    if username == user["username"]:
        raise HTTPException(400, "Нельзя удалить самого себя")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    # Проверяем, что не удаляем последнего владельца
    if users[username]["role"] == "owner":
        owners_count = sum(1 for u in users.values() if u.get("role") == "owner")
        if owners_count <= 1:
            raise HTTPException(400, "Нельзя удалить последнего владельца")
    
    del users[username]
    save_users(users)
    
    return {"message": "Пользователь удален"}

@app.put("/api/users/{username}/role")
async def update_user_role(username: str, data: dict, user: dict = Depends(get_current_user)):
    # Только владелец может изменять роли
    if user["role"] != "owner":
        raise HTTPException(403, "Только владелец может изменять роли")
    
    if username == user["username"]:
        raise HTTPException(400, "Нельзя изменить свою роль")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    new_role = data.get("role")
    if new_role not in ["admin", "user", "support", "banned"]:
        raise HTTPException(400, "Неверная роль")
    
    # Нельзя назначить роль owner
    if new_role == "owner":
        raise HTTPException(400, "Нельзя назначить роль владельца")
    
    users[username]["role"] = new_role
    save_users(users)
    
    return {"message": "Роль обновлена"}

@app.get("/api/users/{username}/permissions")
async def get_user_permissions(username: str, user: dict = Depends(get_current_user)):
    """Получить права пользователя"""
    # Только владелец и админы могут просматривать права
    if user["role"] not in ["owner", "admin"]:
        raise HTTPException(403, "Недостаточно прав")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    target_user = users[username]
    
    # Если у пользователя нет прав, создаем дефолтные
    if "permissions" not in target_user:
        target_user["permissions"] = {
            "servers": True,
            "tickets": True,
            "users": target_user["role"] in ["owner", "admin"],
            "files": True
        }
        users[username] = target_user
        save_users(users)
    
    return {
        "username": username,
        "role": target_user["role"],
        "permissions": target_user["permissions"]
    }

@app.put("/api/users/{username}/permissions")
async def update_user_permissions(username: str, data: dict, user: dict = Depends(get_current_user)):
    """Обновить права пользователя (только для владельца)"""
    if user["role"] != "owner":
        raise HTTPException(403, "Только владелец может изменять права")
    
    if username == user["username"]:
        raise HTTPException(400, "Нельзя изменить свои права")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    target_user = users[username]
    
    # Нельзя изменять права владельца
    if target_user["role"] == "owner":
        raise HTTPException(400, "Нельзя изменять права владельца")
    
    permissions = data.get("permissions", {})
    
    # Валидация прав
    valid_permissions = ["servers", "tickets", "users", "files"]
    for perm in permissions:
        if perm not in valid_permissions:
            raise HTTPException(400, f"Неверное право: {perm}")
    
    # Обновляем права
    if "permissions" not in target_user:
        target_user["permissions"] = {
            "servers": True,
            "tickets": True,
            "users": False,
            "files": True
        }
    
    target_user["permissions"].update(permissions)
    users[username] = target_user
    save_users(users)
    
    return {
        "message": "Права обновлены",
        "permissions": target_user["permissions"]
    }

@app.post("/api/users/{username}/revoke-access")
async def revoke_user_access(username: str, data: dict, user: dict = Depends(get_current_user)):
    """Забрать доступ к определенным ресурсам (только для владельца)"""
    if user["role"] != "owner":
        raise HTTPException(403, "Только владелец может забирать доступ")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    target_user = users[username]
    
    # Нельзя забирать доступ у владельца
    if target_user["role"] == "owner":
        raise HTTPException(400, "Нельзя забирать доступ у владельца")
    
    resource_type = data.get("type")  # "servers", "tickets", "all"
    
    if resource_type == "servers":
        # Забираем доступ ко всем серверам
        target_user["servers"] = []
        if "permissions" in target_user:
            target_user["permissions"]["servers"] = False
    elif resource_type == "tickets":
        # Забираем доступ к тикетам
        if "permissions" in target_user:
            target_user["permissions"]["tickets"] = False
    elif resource_type == "files":
        # Забираем доступ к файлам
        if "permissions" in target_user:
            target_user["permissions"]["files"] = False
    elif resource_type == "all":
        # Забираем весь доступ
        target_user["servers"] = []
        if "permissions" in target_user:
            target_user["permissions"] = {
                "servers": False,
                "tickets": False,
                "users": False,
                "files": False
            }
    else:
        raise HTTPException(400, "Неверный тип ресурса")
    
    users[username] = target_user
    save_users(users)
    
    return {
        "message": f"Доступ к {resource_type} забран",
        "permissions": target_user.get("permissions", {})
    }

@app.post("/api/users/{username}/grant-access")
async def grant_user_access(username: str, data: dict, user: dict = Depends(get_current_user)):
    """Выдать доступ к определенным ресурсам (только для владельца)"""
    if user["role"] != "owner":
        raise HTTPException(403, "Только владелец может выдавать доступ")
    
    users = load_users()
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    target_user = users[username]
    resource_type = data.get("type")  # "servers", "tickets", "files"
    
    if "permissions" not in target_user:
        target_user["permissions"] = {
            "servers": False,
            "tickets": False,
            "users": False,
            "files": False
        }
    
    if resource_type == "servers":
        target_user["permissions"]["servers"] = True
    elif resource_type == "tickets":
        target_user["permissions"]["tickets"] = True
    elif resource_type == "files":
        target_user["permissions"]["files"] = True
    elif resource_type == "all":
        target_user["permissions"] = {
            "servers": True,
            "tickets": True,
            "users": target_user["role"] in ["admin"],
            "files": True
        }
    else:
        raise HTTPException(400, "Неверный тип ресурса")
    
    users[username] = target_user
    save_users(users)
    
    return {
        "message": f"Доступ к {resource_type} выдан",
        "permissions": target_user["permissions"]
    }

# API для личного кабинета
@app.put("/api/profile/username")
async def update_username(data: dict, user: dict = Depends(get_current_user)):
    """Изменить имя пользователя"""
    new_username = data.get("new_username", "").strip()
    password = data.get("password", "")
    
    if not new_username:
        raise HTTPException(400, "Имя пользователя не может быть пустым")
    
    if len(new_username) < 3:
        raise HTTPException(400, "Имя пользователя должно быть не менее 3 символов")
    
    users = load_users()
    
    # Проверяем пароль
    if not verify_password(password, users[user["username"]]["password"]):
        raise HTTPException(400, "Неверный пароль")
    
    # Проверяем, не занято ли новое имя
    if new_username in users and new_username != user["username"]:
        raise HTTPException(400, "Это имя пользователя уже занято")
    
    # Сохраняем данные пользователя
    old_username = user["username"]
    user_data = users[old_username]
    
    # Удаляем старую запись и создаём новую
    del users[old_username]
    user_data["username"] = new_username
    users[new_username] = user_data
    
    # Обновляем владельцев серверов
    for server_dir in SERVERS_DIR.iterdir():
        if server_dir.is_dir():
            config = load_server_config(server_dir.name)
            if config.get("owner") == old_username:
                config["owner"] = new_username
                save_server_config(server_dir.name, config)
    
    # Обновляем доступы к серверам у других пользователей
    for username, user_info in users.items():
        if "servers" in user_info and old_username in user_info.get("servers", []):
            user_info["servers"] = [new_username if s == old_username else s for s in user_info["servers"]]
    
    save_users(users)
    
    # Создаём новый токен
    new_token = create_access_token({"sub": new_username, "role": user_data["role"]})
    
    return {
        "message": "Имя пользователя изменено",
        "access_token": new_token,
        "username": new_username
    }

@app.put("/api/profile/password")
async def update_password(data: dict, user: dict = Depends(get_current_user)):
    """Изменить пароль"""
    old_password = data.get("old_password", "")
    new_password = data.get("new_password", "")
    
    if not old_password or not new_password:
        raise HTTPException(400, "Заполните все поля")
    
    if len(new_password) < 6:
        raise HTTPException(400, "Новый пароль должен быть не менее 6 символов")
    
    users = load_users()
    
    # Проверяем старый пароль
    if not verify_password(old_password, users[user["username"]]["password"]):
        raise HTTPException(400, "Неверный старый пароль")
    
    # Устанавливаем новый пароль
    users[user["username"]]["password"] = get_password_hash(new_password)
    save_users(users)
    
    return {"message": "Пароль изменён"}

@app.get("/api/profile/stats")
async def get_profile_stats(user: dict = Depends(get_current_user)):
    """Получить статистику профиля"""
    users = load_users()
    user_data = users.get(user["username"], {})
    
    # Подсчитываем серверы пользователя
    owned_servers = []
    accessible_servers = []
    
    for server_dir in SERVERS_DIR.iterdir():
        if server_dir.is_dir():
            config = load_server_config(server_dir.name)
            if config.get("owner") == user["username"]:
                owned_servers.append({
                    "name": server_dir.name,
                    "displayName": config.get("displayName", server_dir.name)
                })
            elif user["username"] in user_data.get("servers", []) or user["role"] == "admin":
                accessible_servers.append({
                    "name": server_dir.name,
                    "displayName": config.get("displayName", server_dir.name)
                })
    
    # Подсчитываем тикеты
    tickets = load_tickets()
    user_tickets = [t for t in tickets.values() if t["author"] == user["username"]]
    
    tickets_stats = {
        "total": len(user_tickets),
        "pending": len([t for t in user_tickets if t["status"] == "pending"]),
        "in_progress": len([t for t in user_tickets if t["status"] == "in_progress"]),
        "closed": len([t for t in user_tickets if t["status"] == "closed"])
    }
    
    return {
        "username": user["username"],
        "role": user["role"],
        "owned_servers": owned_servers,
        "accessible_servers": accessible_servers,
        "tickets": tickets_stats,
        "total_servers": len(owned_servers) + len(accessible_servers)
    }

@app.get("/api/profile/stats/{username}")
async def get_user_profile_stats(username: str, user: dict = Depends(get_current_user)):
    """Получить статистику профиля другого пользователя (только для админов и тех. поддержки)"""
    # Проверка прав доступа
    if user["role"] not in ["admin", "support"]:
        raise HTTPException(403, "Недостаточно прав для просмотра профилей других пользователей")
    
    users = load_users()
    
    # Проверка существования пользователя
    if username not in users:
        raise HTTPException(404, "Пользователь не найден")
    
    target_user = users[username]
    
    # Подсчитываем серверы пользователя
    owned_servers = []
    accessible_servers = []
    
    for server_dir in SERVERS_DIR.iterdir():
        if server_dir.is_dir():
            config = load_server_config(server_dir.name)
            if config.get("owner") == username:
                owned_servers.append({
                    "name": server_dir.name,
                    "displayName": config.get("displayName", server_dir.name)
                })
            elif username in target_user.get("servers", []) or target_user["role"] == "admin":
                accessible_servers.append({
                    "name": server_dir.name,
                    "displayName": config.get("displayName", server_dir.name)
                })
    
    # Подсчитываем тикеты
    tickets = load_tickets()
    user_tickets = [t for t in tickets.values() if t["author"] == username]
    
    tickets_stats = {
        "total": len(user_tickets),
        "pending": len([t for t in user_tickets if t["status"] == "pending"]),
        "in_progress": len([t for t in user_tickets if t["status"] == "in_progress"]),
        "closed": len([t for t in user_tickets if t["status"] == "closed"])
    }
    
    return {
        "username": username,
        "role": target_user["role"],
        "owned_servers": owned_servers,
        "accessible_servers": accessible_servers,
        "tickets": tickets_stats,
        "total_servers": len(owned_servers) + len(accessible_servers),
        "is_viewing_other": True  # Флаг что это чужой профиль
    }

# API для серверов
@app.get("/api/servers")
async def get_servers(user: dict = Depends(get_current_user)):
    servers = []
    try:
        # Владелец и администратор видят все серверы
        is_admin_or_owner = user.get("role") in ["owner", "admin"]
        
        for server_dir in SERVERS_DIR.iterdir():
            if server_dir.is_dir():
                # Проверка доступа: владелец/админ видят всё, остальные только свои
                if not is_admin_or_owner and server_dir.name not in user.get("servers", []):
                    continue
                
                config = load_server_config(server_dir.name)
                
                is_running = False
                if server_dir.name in server_processes:
                    process = server_processes[server_dir.name]
                    if process.poll() is None:
                        is_running = True
                    else:
                        del server_processes[server_dir.name]
                
                servers.append({
                    "name": server_dir.name,
                    "displayName": config.get("displayName", server_dir.name),
                    "status": "running" if is_running else "stopped",
                    "owner": config.get("owner", "unknown")
                })
        
        print(f"[DEBUG] User: {user['username']} (role: {user.get('role', 'user')})")
        print(f"[DEBUG] Is admin/owner: {is_admin_or_owner}")
        print(f"[DEBUG] Servers found: {len(servers)}")
        
    except Exception as e:
        print(f"Ошибка загрузки серверов: {e}")
    return servers

@app.post("/api/servers/create")
async def create_server(data: dict, user: dict = Depends(get_current_user)):
    server_name = data.get("name", "").strip()
    daemon_id = data.get("daemonId", "local")
    
    if not server_name or not server_name.replace("_", "").replace("-", "").isalnum():
        raise HTTPException(400, "Недопустимое имя сервера")
    
    # Если создаем на демоне
    if daemon_id != "local":
        # Загружаем демоны
        from daemons import load_daemons
        daemons = load_daemons()
        
        if daemon_id not in daemons:
            raise HTTPException(404, "Демон не найден")
        
        daemon = daemons[daemon_id]
        
        # Отправляем запрос на создание сервера на демоне
        url = f"http://{daemon['address']}:{daemon['port']}/api/servers/create"
        headers = {"Authorization": f"Bearer {daemon['key']}"}
        
        try:
            async with httpx.AsyncClient(timeout=10.0) as client:
                response = await client.post(url, json={
                    "name": server_name,
                    "displayName": data.get("displayName", server_name),
                    "startCommand": data.get("startCommand", "java -Xmx2G -Xms1G -jar server.jar nogui"),
                    "owner": user["username"]
                }, headers=headers)
                
                if response.status_code != 200:
                    raise HTTPException(400, f"Ошибка создания сервера на демоне: {response.text}")
        except httpx.RequestError as e:
            raise HTTPException(400, f"Ошибка подключения к демону: {str(e)}")
        
        # Сохраняем информацию о сервере локально
        config = {
            "name": server_name,
            "displayName": data.get("displayName", server_name),
            "startCommand": data.get("startCommand", "java -Xmx2G -Xms1G -jar server.jar nogui"),
            "owner": user["username"],
            "daemonId": daemon_id,
            "daemonName": daemon["name"]
        }
        
        # Создаем локальную запись о сервере
        server_path = SERVERS_DIR / f"{daemon_id}_{server_name}"
        server_path.mkdir(parents=True, exist_ok=True)
        save_server_config(f"{daemon_id}_{server_name}", config)
        
    else:
        # Создаем локально
        server_path = SERVERS_DIR / server_name
        if server_path.exists():
            raise HTTPException(400, "Сервер с таким именем уже существует")
        
        server_path.mkdir(parents=True)
        
        config = {
            "name": server_name,
            "displayName": data.get("displayName", server_name),
            "startCommand": data.get("startCommand", "java -Xmx2G -Xms1G -jar server.jar nogui"),
            "owner": user["username"],
            "daemonId": "local"
        }
        save_server_config(server_name, config)
    
    # Если пользователь не админ/owner, автоматически выдаем ему доступ
    if user["role"] not in ["admin", "owner"]:
        users = load_users()
        if user["username"] in users:
            if "servers" not in users[user["username"]]:
                users[user["username"]]["servers"] = []
            server_key = f"{daemon_id}_{server_name}" if daemon_id != "local" else server_name
            if server_key not in users[user["username"]]["servers"]:
                users[user["username"]]["servers"].append(server_key)
            save_users(users)
    
    return {"message": "Сервер создан", "name": server_name, "daemonId": daemon_id}

@app.get("/api/servers/{server_name}/config")
async def get_server_config(server_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    if not server_path.exists():
        raise HTTPException(404, "Сервер не найден")
    
    config = load_server_config(server_name)
    print(f"Загружена конфигурация для {server_name}: {config}")
    return config

@app.put("/api/servers/{server_name}/config")
async def update_server_config(server_name: str, config: dict, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    if not server_path.exists():
        raise HTTPException(404, "Сервер не найден")
    
    if server_name in server_processes:
        raise HTTPException(400, "Остановите сервер перед изменением настроек")
    
    save_server_config(server_name, config)
    return {"message": "Настройки сохранены"}

@app.delete("/api/servers/{server_name}")
async def delete_server(server_name: str, user: dict = Depends(get_current_user)):
    if user["role"] != "admin":
        raise HTTPException(403, "Только администраторы могут удалять серверы")
    
    server_path = SERVERS_DIR / server_name
    if not server_path.exists():
        raise HTTPException(404, "Сервер не найден")
    
    if server_name in server_processes:
        raise HTTPException(400, "Остановите сервер перед удалением")
    
    shutil.rmtree(server_path)
    return {"message": "Сервер удален"}

# Управление процессами серверов
async def read_server_output(server_name: str, process: subprocess.Popen):
    try:
        print(f"Начало чтения вывода для сервера {server_name}")
        loop = asyncio.get_event_loop()
        
        while True:
            if process.poll() is not None:
                print(f"Процесс сервера {server_name} завершился с кодом {process.poll()}")
                break
            
            try:
                line = await loop.run_in_executor(None, process.stdout.readline)
                if not line:
                    break
                
                line = line.strip()
                if line:
                    if server_name not in server_logs:
                        server_logs[server_name] = []
                    server_logs[server_name].append(line)
                    
                    if len(server_logs[server_name]) > 1000:
                        server_logs[server_name].pop(0)
            except Exception as e:
                print(f"Ошибка чтения строки для {server_name}: {e}")
                await asyncio.sleep(0.1)
                
    except Exception as e:
        print(f"Ошибка чтения вывода сервера {server_name}: {e}")
    finally:
        print(f"Чтение вывода для сервера {server_name} завершено")
        if server_name in server_processes and process.poll() is not None:
            del server_processes[server_name]
            print(f"Сервер {server_name} удален из списка процессов")

@app.post("/api/servers/{server_name}/start")
async def start_server(server_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    if not server_path.exists():
        raise HTTPException(404, "Сервер не найден")
    
    if server_name in server_processes:
        raise HTTPException(400, "Сервер уже запущен")
    
    config = load_server_config(server_name)
    start_command = config.get("startCommand", "java -Xmx2G -Xms1G -jar server.jar nogui")
    
    cmd_parts = start_command.split()
    
    try:
        if IS_WINDOWS:
            process = subprocess.Popen(
                cmd_parts,
                cwd=server_path,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1,
                creationflags=subprocess.CREATE_NO_WINDOW
            )
        else:
            process = subprocess.Popen(
                cmd_parts,
                cwd=server_path,
                stdin=subprocess.PIPE,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                bufsize=1
            )
        
        server_processes[server_name] = process
        server_logs[server_name] = []
        
        asyncio.create_task(read_server_output(server_name, process))
        
        print(f"Сервер {server_name} запущен с PID {process.pid}")
        return {"message": "Сервер запущен", "pid": process.pid}
    except Exception as e:
        print(f"Ошибка запуска сервера {server_name}: {e}")
        raise HTTPException(500, f"Ошибка запуска сервера: {str(e)}")

@app.post("/api/servers/{server_name}/stop")
async def stop_server(server_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    if server_name not in server_processes:
        raise HTTPException(400, "Сервер не запущен")
    
    process = server_processes[server_name]
    
    try:
        if process.stdin and not process.stdin.closed:
            process.stdin.write("stop\n")
            process.stdin.flush()
        
        try:
            process.wait(timeout=30)
        except subprocess.TimeoutExpired:
            print(f"Сервер {server_name} не остановился за 30 секунд, принудительное завершение")
            process.kill()
            process.wait()
    except Exception as e:
        print(f"Ошибка при остановке сервера {server_name}: {e}")
        try:
            process.kill()
            process.wait()
        except:
            pass
    finally:
        if server_name in server_processes:
            del server_processes[server_name]
        print(f"Сервер {server_name} остановлен")
    
    return {"message": "Сервер остановлен"}

@app.post("/api/servers/{server_name}/command")
async def send_command(server_name: str, command: dict, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    if server_name not in server_processes:
        raise HTTPException(400, "Сервер не запущен")
    
    process = server_processes[server_name]
    
    if process.poll() is not None:
        del server_processes[server_name]
        raise HTTPException(400, "Сервер не запущен")
    
    try:
        cmd = command["command"]
        if process.stdin and not process.stdin.closed:
            process.stdin.write(cmd + "\n")
            process.stdin.flush()
            print(f"Команда отправлена серверу {server_name}: {cmd}")
            return {"message": "Команда отправлена"}
        else:
            raise HTTPException(400, "Невозможно отправить команду")
    except Exception as e:
        print(f"Ошибка отправки команды серверу {server_name}: {e}")
        raise HTTPException(500, f"Ошибка отправки команды: {str(e)}")

@app.get("/api/servers/{server_name}/stats")
async def get_server_stats(server_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    
    try:
        disk_usage = sum(f.stat().st_size for f in server_path.rglob('*') if f.is_file())
        disk_mb = disk_usage / 1024 / 1024
    except:
        disk_mb = 0
    
    if server_name not in server_processes:
        return {
            "status": "stopped",
            "cpu": 0,
            "memory": 0,
            "disk": round(disk_mb, 2)
        }
    
    process = server_processes[server_name]
    try:
        if process.poll() is not None:
            del server_processes[server_name]
            return {
                "status": "stopped",
                "cpu": 0,
                "memory": 0,
                "disk": round(disk_mb, 2)
            }
        
        proc = psutil.Process(process.pid)
        memory_mb = proc.memory_info().rss / 1024 / 1024
        cpu_percent = proc.cpu_percent(interval=0.1)
        
        return {
            "status": "running",
            "cpu": round(cpu_percent, 2),
            "memory": round(memory_mb, 2),
            "disk": round(disk_mb, 2)
        }
    except (psutil.NoSuchProcess, psutil.AccessDenied):
        if server_name in server_processes:
            del server_processes[server_name]
        return {
            "status": "stopped",
            "cpu": 0,
            "memory": 0,
            "disk": round(disk_mb, 2)
        }
    except Exception as e:
        print(f"Ошибка получения статистики для {server_name}: {e}")
        return {
            "status": "unknown",
            "cpu": 0,
            "memory": 0,
            "disk": round(disk_mb, 2)
        }

@app.websocket("/ws/servers/{server_name}/console")
async def console_websocket(websocket: WebSocket, server_name: str):
    await websocket.accept()
    print(f"WebSocket подключен для сервера: {server_name}")
    
    if server_name in server_logs:
        print(f"Отправка {len(server_logs[server_name])} существующих логов")
        for log in server_logs[server_name]:
            await websocket.send_text(log)
    else:
        print(f"Логов для сервера {server_name} пока нет")
        await websocket.send_text(f"[Панель] Ожидание логов от сервера {server_name}...")
    
    last_sent_index = len(server_logs.get(server_name, []))
    
    try:
        while True:
            if server_name in server_logs:
                current_logs = server_logs[server_name]
                if len(current_logs) > last_sent_index:
                    for log in current_logs[last_sent_index:]:
                        await websocket.send_text(log)
                    last_sent_index = len(current_logs)
            await asyncio.sleep(0.1)
    except Exception as e:
        print(f"WebSocket ошибка: {e}")
        pass

# API для файлов
@app.get("/api/servers/{server_name}/files")
async def list_files(server_name: str, path: str = "", user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    if not server_path.exists():
        raise HTTPException(404, "Сервер не найден")
    
    target_path = server_path / path if path else server_path
    
    try:
        target_path = target_path.resolve()
        server_path = server_path.resolve()
        if not str(target_path).startswith(str(server_path)):
            raise HTTPException(403, "Доступ запрещен")
    except:
        raise HTTPException(404, "Путь не найден")
    
    if not target_path.exists():
        raise HTTPException(404, "Путь не найден")
    
    if not target_path.is_dir():
        raise HTTPException(400, "Путь не является директорией")
    
    files = []
    try:
        for item in target_path.iterdir():
            files.append({
                "name": item.name,
                "type": "directory" if item.is_dir() else "file",
                "size": item.stat().st_size if item.is_file() else 0
            })
    except Exception as e:
        print(f"Ошибка чтения директории: {e}")
        raise HTTPException(500, f"Ошибка чтения директории: {str(e)}")
    
    return files

@app.get("/api/servers/{server_name}/files/download")
async def download_file(server_name: str, path: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    file_path = server_path / path
    
    if not file_path.exists() or not str(file_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    return FileResponse(file_path, filename=file_path.name)

@app.post("/api/servers/{server_name}/files/upload")
async def upload_file(server_name: str, path: str, file: UploadFile = File(...), user: dict = Depends(get_current_user)):
    print(f"Upload request: server={server_name}, path='{path}', filename='{file.filename}'")
    
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    target_path = server_path / path / file.filename
    
    print(f"Target path: {target_path}")
    print(f"Server path: {server_path}")
    print(f"Path starts with server_path: {str(target_path).startswith(str(server_path))}")
    
    if not str(target_path).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимый путь")
    
    try:
        target_path.parent.mkdir(parents=True, exist_ok=True)
        print(f"Created directory: {target_path.parent}")
    except Exception as e:
        print(f"Error creating directory: {e}")
        raise HTTPException(500, f"Ошибка создания директории: {str(e)}")
    
    try:
        with open(target_path, "wb") as f:
            content = await file.read()
            f.write(content)
        print(f"File written successfully: {target_path}")
    except Exception as e:
        print(f"Error writing file: {e}")
        raise HTTPException(500, f"Ошибка записи файла: {str(e)}")
    
    return {"message": "Файл загружен"}

@app.post("/api/servers/{server_name}/files/create")
async def create_file_or_folder(server_name: str, data: dict, user: dict = Depends(get_current_user)):
    """Создать новый файл или папку"""
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    item_type = data.get("type")  # "file" or "folder"
    name = data.get("name", "").strip()
    path = data.get("path", "")  # Текущая папка
    
    if not name:
        raise HTTPException(400, "Имя не может быть пустым")
    
    if item_type not in ["file", "folder"]:
        raise HTTPException(400, "Тип должен быть 'file' или 'folder'")
    
    server_path = SERVERS_DIR / server_name
    
    # Формируем полный путь
    if path:
        full_path = server_path / path / name
    else:
        full_path = server_path / name
    
    print(f"Creating {item_type}: {full_path}")
    
    # Проверка безопасности
    if not str(full_path).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимый путь")
    
    try:
        if item_type == "folder":
            # Создаем папку
            full_path.mkdir(parents=True, exist_ok=True)
            # Создаем .gitkeep чтобы папка не была пустой
            gitkeep = full_path / ".gitkeep"
            gitkeep.touch()
            print(f"Folder created: {full_path}")
        else:
            # Создаем файл
            full_path.parent.mkdir(parents=True, exist_ok=True)
            full_path.touch()
            print(f"File created: {full_path}")
        
        return {"message": f"{'Папка' if item_type == 'folder' else 'Файл'} создан(а)", "path": str(full_path)}
    except Exception as e:
        print(f"Error creating {item_type}: {e}")
        raise HTTPException(500, f"Ошибка создания: {str(e)}")

@app.delete("/api/servers/{server_name}/files")
async def delete_file(server_name: str, path: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    target_path = server_path / path
    
    if not target_path.exists() or not str(target_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    if target_path.is_dir():
        shutil.rmtree(target_path)
    else:
        target_path.unlink()
    
    return {"message": "Файл удален"}

@app.get("/api/servers/{server_name}/files/content")
async def get_file_content(server_name: str, path: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    file_path = server_path / path
    
    if not file_path.exists() or not file_path.is_file() or not str(file_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
        return {"content": content}
    except UnicodeDecodeError:
        raise HTTPException(400, "Файл не является текстовым")

@app.put("/api/servers/{server_name}/files/content")
async def update_file_content(server_name: str, path: str, data: dict, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    file_path = server_path / path
    
    if not file_path.exists() or not file_path.is_file() or not str(file_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    try:
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(data.get("content", ""))
        return {"message": "Файл сохранен"}
    except Exception as e:
        raise HTTPException(400, f"Ошибка сохранения файла: {str(e)}")

@app.put("/api/servers/{server_name}/files/rename")
async def rename_file(server_name: str, old_path: str, new_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    old_file_path = server_path / old_path
    
    if not old_file_path.exists() or not str(old_file_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    new_file_path = old_file_path.parent / new_name
    
    if new_file_path.exists():
        raise HTTPException(400, "Файл с таким именем уже существует")
    
    if not str(new_file_path).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимое имя файла")
    
    old_file_path.rename(new_file_path)
    return {"message": "Файл переименован"}

@app.post("/api/servers/{server_name}/files/move")
async def move_file(server_name: str, data: dict, user: dict = Depends(get_current_user)):
    """Переместить файл или папку"""
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    source_path = data.get("source", "").strip()
    destination_path = data.get("destination", "").strip()
    
    if not source_path:
        raise HTTPException(400, "Не указан исходный путь")
    
    server_path = SERVERS_DIR / server_name
    source_full = server_path / source_path
    
    # Формируем путь назначения
    if destination_path:
        # Извлекаем имя файла из source_path
        file_name = source_full.name
        dest_full = server_path / destination_path / file_name
    else:
        # Перемещение в корень
        file_name = source_full.name
        dest_full = server_path / file_name
    
    print(f"Moving: {source_full} -> {dest_full}")
    
    # Проверки безопасности
    if not source_full.exists():
        raise HTTPException(404, "Исходный файл не найден")
    
    if not str(source_full).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимый исходный путь")
    
    if not str(dest_full).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимый путь назначения")
    
    if dest_full.exists():
        raise HTTPException(400, "Файл с таким именем уже существует в папке назначения")
    
    try:
        # Создаем папку назначения если не существует
        dest_full.parent.mkdir(parents=True, exist_ok=True)
        
        # Перемещаем файл/папку
        import shutil
        shutil.move(str(source_full), str(dest_full))
        
        print(f"Moved successfully: {dest_full}")
        return {"message": "Файл перемещен", "new_path": str(dest_full)}
    except Exception as e:
        print(f"Error moving file: {e}")
        raise HTTPException(500, f"Ошибка перемещения: {str(e)}")

@app.put("/api/servers/{server_name}/files/rename")
async def rename_file(server_name: str, old_path: str, new_name: str, user: dict = Depends(get_current_user)):
    if not check_server_access(user, server_name):
        raise HTTPException(403, "Нет доступа к этому серверу")
    
    server_path = SERVERS_DIR / server_name
    old_file_path = server_path / old_path
    
    if not old_file_path.exists() or not str(old_file_path).startswith(str(server_path)):
        raise HTTPException(404, "Файл не найден")
    
    new_file_path = old_file_path.parent / new_name
    
    if new_file_path.exists():
        raise HTTPException(400, "Файл с таким именем уже существует")
    
    if not str(new_file_path).startswith(str(server_path)):
        raise HTTPException(400, "Недопустимое имя файла")
    
    old_file_path.rename(new_file_path)
    return {"message": "Файл переименован"}

# API для тикетов
@app.get("/api/tickets")
async def get_tickets(user: dict = Depends(get_current_user)):
    """Получить список тикетов"""
    # Проверяем права на тикеты
    if not user.get("permissions", {}).get("tickets", True):
        raise HTTPException(403, "Нет доступа к тикетам")
    
    tickets = load_tickets()
    
    # Владелец, админы и тех. поддержка видят все тикеты
    if user["role"] in ["owner", "admin", "support"]:
        return list(tickets.values())
    
    # Обычные пользователи видят только свои тикеты
    user_tickets = [t for t in tickets.values() if t["author"] == user["username"]]
    return user_tickets

@app.post("/api/tickets/create")
async def create_ticket(data: dict, user: dict = Depends(get_current_user)):
    """Создать новый тикет"""
    # Проверяем права на тикеты
    if not user.get("permissions", {}).get("tickets", True):
        raise HTTPException(403, "Нет доступа к тикетам")
    
    tickets = load_tickets()
    
    # Генерируем ID тикета
    ticket_id = str(len(tickets) + 1)
    
    ticket = {
        "id": ticket_id,
        "title": data.get("title", "").strip(),
        "description": data.get("description", "").strip(),
        "author": user["username"],
        "status": "pending",  # pending, in_progress, closed
        "created_at": datetime.utcnow().isoformat(),
        "updated_at": datetime.utcnow().isoformat(),
        "messages": [
            {
                "author": user["username"],
                "text": data.get("description", "").strip(),
                "timestamp": datetime.utcnow().isoformat()
            }
        ]
    }
    
    tickets[ticket_id] = ticket
    save_tickets(tickets)
    
    return {"message": "Тикет создан", "ticket": ticket}

@app.get("/api/tickets/{ticket_id}")
async def get_ticket(ticket_id: str, user: dict = Depends(get_current_user)):
    """Получить тикет по ID"""
    # Проверяем права на тикеты
    if not user.get("permissions", {}).get("tickets", True):
        raise HTTPException(403, "Нет доступа к тикетам")
    
    tickets = load_tickets()
    
    if ticket_id not in tickets:
        raise HTTPException(404, "Тикет не найден")
    
    ticket = tickets[ticket_id]
    
    # Проверка доступа
    if user["role"] not in ["owner", "admin", "support"] and ticket["author"] != user["username"]:
        raise HTTPException(403, "Нет доступа к этому тикету")
    
    return ticket

@app.post("/api/tickets/{ticket_id}/message")
async def add_ticket_message(ticket_id: str, data: dict, user: dict = Depends(get_current_user)):
    """Добавить сообщение в тикет"""
    # Проверяем права на тикеты
    if not user.get("permissions", {}).get("tickets", True):
        raise HTTPException(403, "Нет доступа к тикетам")
    
    tickets = load_tickets()
    
    if ticket_id not in tickets:
        raise HTTPException(404, "Тикет не найден")
    
    ticket = tickets[ticket_id]
    
    # Проверка доступа
    if user["role"] not in ["owner", "admin", "support"] and ticket["author"] != user["username"]:
        raise HTTPException(403, "Нет доступа к этому тикету")
    
    message = {
        "author": user["username"],
        "text": data.get("text", "").strip(),
        "timestamp": datetime.utcnow().isoformat()
    }
    
    ticket["messages"].append(message)
    ticket["updated_at"] = datetime.utcnow().isoformat()
    
    tickets[ticket_id] = ticket
    save_tickets(tickets)
    
    return {"message": "Сообщение добавлено", "ticket": ticket}

@app.put("/api/tickets/{ticket_id}/status")
async def update_ticket_status(ticket_id: str, data: dict, user: dict = Depends(get_current_user)):
    """Изменить статус тикета (только для владельца, админов и тех. поддержки)"""
    if user["role"] not in ["owner", "admin", "support"]:
        raise HTTPException(403, "Недостаточно прав")
    
    # Проверяем права на тикеты
    if not user.get("permissions", {}).get("tickets", True):
        raise HTTPException(403, "Нет доступа к тикетам")
    
    tickets = load_tickets()
    
    if ticket_id not in tickets:
        raise HTTPException(404, "Тикет не найден")
    
    new_status = data.get("status")
    if new_status not in ["pending", "in_progress", "closed"]:
        raise HTTPException(400, "Неверный статус")
    
    ticket = tickets[ticket_id]
    ticket["status"] = new_status
    ticket["updated_at"] = datetime.utcnow().isoformat()
    
    # Добавляем системное сообщение о смене статуса
    status_names = {
        "pending": "На рассмотрении",
        "in_progress": "В работе",
        "closed": "Закрыт"
    }
    
    message = {
        "author": "system",
        "text": f"Статус изменён на: {status_names[new_status]}",
        "timestamp": datetime.utcnow().isoformat()
    }
    
    ticket["messages"].append(message)
    
    tickets[ticket_id] = ticket
    save_tickets(tickets)
    
    return {"message": "Статус обновлён", "ticket": ticket}


# ============================================
# УПРАВЛЕНИЕ ПОЛЬЗОВАТЕЛЯМИ (v1.1.0)
# ============================================

# Загрузка пользователей
def load_users_dict():
    users_file = Path("users.json")
    if not users_file.exists():
        return {}
    with open(users_file, "r", encoding="utf-8") as f:
        return json.load(f)

def save_users_dict(users):
    with open("users.json", "w", encoding="utf-8") as f:
        json.dump(users, f, indent=2, ensure_ascii=False)

# Проверка прав
def require_owner(current_user: dict):
    if current_user.get("role") != "owner":
        raise HTTPException(status_code=403, detail="Требуется роль владельца")

def require_admin_or_owner(current_user: dict):
    if current_user.get("role") not in ["owner", "admin"]:
        raise HTTPException(status_code=403, detail="Требуется роль администратора или владельца")

# 1. Получить список пользователей
@app.get("/api/users")
async def get_users(current_user: dict = Depends(get_current_user)):
    require_admin_or_owner(current_user)
    
    users = load_users_dict()
    users_list = []
    for username, user_data in users.items():
        user_copy = user_data.copy()
        user_copy.pop("password", None)
        users_list.append(user_copy)
    
    return users_list

# 2. Изменить роль пользователя
class RoleChange(BaseModel):
    role: str

@app.put("/api/users/{username}/role")
async def change_user_role(username: str, role_data: RoleChange, current_user: dict = Depends(get_current_user)):
    require_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if username == current_user.get("username"):
        raise HTTPException(status_code=400, detail="Нельзя изменить свою роль")
    
    valid_roles = ["owner", "admin", "support", "user", "banned"]
    if role_data.role not in valid_roles:
        raise HTTPException(status_code=400, detail=f"Неверная роль")
    
    # Разрешаем несколько владельцев (убрано ограничение на одного)
    # Теперь можно назначить несколько пользователей с ролью owner
    
    old_role = users[username].get("role", "user")
    users[username]["role"] = role_data.role
    
    # Обновляем права
    if role_data.role == "owner":
        users[username]["permissions"] = {
            "manage_users": True, "manage_roles": True, "manage_servers": True,
            "manage_tickets": True, "manage_files": True, "delete_users": True,
            "view_all_resources": True
        }
    elif role_data.role == "admin":
        users[username]["permissions"] = {
            "manage_users": True, "manage_roles": False, "manage_servers": True,
            "manage_tickets": True, "manage_files": True, "delete_users": False,
            "view_all_resources": True
        }
    elif role_data.role == "support":
        users[username]["permissions"] = {
            "manage_users": False, "manage_roles": False, "manage_servers": False,
            "manage_tickets": True, "manage_files": False, "delete_users": False,
            "view_all_resources": False
        }
    elif role_data.role == "banned":
        users[username]["permissions"] = {
            "manage_users": False, "manage_roles": False, "manage_servers": False,
            "manage_tickets": False, "manage_files": False, "delete_users": False,
            "view_all_resources": False
        }
    else:  # user
        users[username]["permissions"] = {
            "manage_users": False, "manage_roles": False, "manage_servers": True,
            "manage_tickets": True, "manage_files": True, "delete_users": False,
            "view_all_resources": False
        }
    
    save_users_dict(users)
    
    return {"message": f"Роль изменена с {old_role} на {role_data.role}", "user": {"username": username, "role": role_data.role}}

# 3. Заблокировать пользователя
class BanRequest(BaseModel):
    reason: str = "Заблокирован администратором"

@app.post("/api/users/{username}/ban")
async def ban_user(username: str, ban_data: BanRequest, current_user: dict = Depends(get_current_user)):
    require_admin_or_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if username == current_user.get("username"):
        raise HTTPException(status_code=400, detail="Нельзя заблокировать самого себя")
    
    # Проверяем, что не блокируем последнего владельца
    if users[username].get("role") == "owner":
        owners_count = sum(1 for u in users.values() if u.get("role") == "owner")
        if owners_count <= 1:
            raise HTTPException(status_code=400, detail="Нельзя заблокировать последнего владельца. Должен остаться хотя бы один владелец.")
    
    users[username]["role"] = "banned"
    users[username]["permissions"] = {
        "manage_users": False, "manage_roles": False, "manage_servers": False,
        "manage_tickets": False, "manage_files": False, "delete_users": False,
        "view_all_resources": False
    }
    users[username]["ban_reason"] = ban_data.reason
    
    save_users_dict(users)
    
    return {"message": f"Пользователь {username} заблокирован", "username": username, "reason": ban_data.reason}

# 4. Разблокировать пользователя
@app.post("/api/users/{username}/unban")
async def unban_user(username: str, current_user: dict = Depends(get_current_user)):
    require_admin_or_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if users[username].get("role") != "banned":
        raise HTTPException(status_code=400, detail="Пользователь не заблокирован")
    
    users[username]["role"] = "user"
    users[username]["permissions"] = {
        "manage_users": False, "manage_roles": False, "manage_servers": True,
        "manage_tickets": True, "manage_files": True, "delete_users": False,
        "view_all_resources": False
    }
    users[username].pop("ban_reason", None)
    
    save_users_dict(users)
    
    return {"message": f"Пользователь {username} разблокирован", "username": username}

# 5. Удалить пользователя
@app.delete("/api/users/{username}")
async def delete_user(username: str, current_user: dict = Depends(get_current_user)):
    require_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if username == current_user.get("username"):
        raise HTTPException(status_code=400, detail="Нельзя удалить самого себя")
    
    # Проверяем, что не удаляем последнего владельца
    if users[username].get("role") == "owner":
        owners_count = sum(1 for u in users.values() if u.get("role") == "owner")
        if owners_count <= 1:
            raise HTTPException(status_code=400, detail="Нельзя удалить последнего владельца. Должен остаться хотя бы один владелец.")
    
    del users[username]
    save_users_dict(users)
    
    return {"message": f"Пользователь {username} удалён", "username": username}

# 6. Выдать доступ к серверу
class ServerAccess(BaseModel):
    server_name: str

@app.post("/api/users/{username}/access/servers")
async def grant_server_access(username: str, access: ServerAccess, current_user: dict = Depends(get_current_user)):
    require_admin_or_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if "resource_access" not in users[username]:
        users[username]["resource_access"] = {"servers": [], "tickets": [], "files": []}
    
    if access.server_name not in users[username]["resource_access"]["servers"]:
        users[username]["resource_access"]["servers"].append(access.server_name)
    
    # Также добавляем в старое поле servers для совместимости
    if "servers" not in users[username]:
        users[username]["servers"] = []
    if access.server_name not in users[username]["servers"]:
        users[username]["servers"].append(access.server_name)
    
    save_users_dict(users)
    
    return {"message": f"Доступ к серверу {access.server_name} выдан", "server": access.server_name, "user": username}

# 7. Забрать доступ к серверу
@app.delete("/api/users/{username}/access/servers/{server_name}")
async def revoke_server_access(username: str, server_name: str, current_user: dict = Depends(get_current_user)):
    require_admin_or_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    if "resource_access" in users[username] and "servers" in users[username]["resource_access"]:
        if server_name in users[username]["resource_access"]["servers"]:
            users[username]["resource_access"]["servers"].remove(server_name)
    
    # Также удаляем из старого поля servers
    if "servers" in users[username] and server_name in users[username]["servers"]:
        users[username]["servers"].remove(server_name)
    
    save_users_dict(users)
    
    return {"message": f"Доступ к серверу {server_name} отозван", "server": server_name, "user": username}

# 8. Изменить права пользователя
class PermissionsUpdate(BaseModel):
    permissions: dict

@app.put("/api/users/{username}/permissions")
async def update_user_permissions(username: str, perms: PermissionsUpdate, current_user: dict = Depends(get_current_user)):
    require_owner(current_user)
    
    users = load_users_dict()
    
    if username not in users:
        raise HTTPException(status_code=404, detail="Пользователь не найден")
    
    users[username]["permissions"] = perms.permissions
    save_users_dict(users)
    
    return {"message": f"Права пользователя {username} обновлены", "permissions": perms.permissions}


# ============================================
# API для управления демонами
# ============================================

from daemons import router as daemons_router

# Подключаем роутер демонов
app.include_router(daemons_router)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)