import { auth, db } from "./firebase-config.js";

import {
  onAuthStateChanged
} from "https://www.gstatic.com/firebasejs/10.12.2/firebase-auth.js";

import {
  collection,
  getDocs,
  doc,
  getDoc,
  updateDoc,
  setDoc,
  addDoc,
  deleteDoc,
  onSnapshot,
  query,
  where,
  orderBy
} from "https://www.gstatic.com/firebasejs/10.12.2/firebase-firestore.js";

let currentUser = null;
let currentUserData = null;
let currentRole = "guest";
let allUsers = [];
let roleFilter = "all";
let roleSearchText = "";
let rolePage = 1;

const usersPerPage = 5;
const USERS_CACHE_TTL = 60 * 1000;

let usersLoadedAt = 0;
let roleLoadingPromise = null;
let roleRenderRequestId = 0;

function notify(message, type = "success") {
  if (window.showToast) window.showToast(message, type);
  else alert(message);
}

function escapeHTML(text) {
  return String(text || "")
    .replaceAll("&", "&")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#039;");
}

function escapeAttr(text) {
  return escapeHTML(text).replaceAll("`", "&#096;");
}

function normalizeRole(role) {
  const clean = String(role || "user").trim().toLowerCase();

  if (["admin", "operator", "supporter", "user"].includes(clean)) {
    return clean;
  }

  if (clean === "destek" || clean === "destek üye" || clean === "support") return "supporter";
  if (clean === "standart" || clean === "standard") return "user";
  if (clean === "operatör") return "operator";

  return "user";
}

function roleLabel(role) {
  const clean = normalizeRole(role);
  if (clean === "admin") return "Admin";
  if (clean === "operator") return "Operatör";
  if (clean === "supporter") return "Destek Üye";
  return "Standart Üye";
}

function isBanned(user) {
  return user?.banned === true || user?.status === "banned";
}

const ONLINE_TIMEOUT_MS = 2 * 60 * 1000;

function timestampToMs(value) {
  if (!value) return 0;
  if (typeof value === "number") return value;
  if (typeof value.toMillis === "function") return value.toMillis();
  if (typeof value.seconds === "number") return value.seconds * 1000;
  return 0;
}

function isActiveUser(user) {
  if (isBanned(user)) return false;

  const lastActiveAt = timestampToMs(user?.lastActiveAt);
  if (!lastActiveAt) return false;

  return user?.online === true && Date.now() - lastActiveAt <= ONLINE_TIMEOUT_MS;
}

function displayName(user) {
  return user?.username || `${user?.firstName || ""} ${user?.lastName || ""}`.trim() || user?.email || "Kullanıcı";
}


function roleChatId(adminUid, userUid) {
  return `${String(adminUid || "").trim()}_${String(userUid || "").trim()}`;
}

function currentAdminName() {
  return currentUserData?.username
    || `${currentUserData?.firstName || ""} ${currentUserData?.lastName || ""}`.trim()
    || currentUser?.email
    || "Admin";
}

function chatPreviewReason(text, fallback = "Sebep belirtilmedi.") {
  const clean = String(text || "").trim();
  return clean || fallback;
}

let activeRoleChatId = "";
let activeRoleChatUser = null;
let unsubscribeRoleChatMessages = null;

function stopRoleChatMessageListener() {
  if (unsubscribeRoleChatMessages) {
    unsubscribeRoleChatMessages();
    unsubscribeRoleChatMessages = null;
  }
}

function ensureRoleChatBox() {
  let box = document.getElementById("rolePrivateChatBox");
  if (box) return box;

  box = document.createElement("div");
  box.id = "rolePrivateChatBox";
  box.className = "role-private-chat-box hidden";
  box.innerHTML = `
    <div class="role-private-chat-head">
      <div>
        <strong id="rolePrivateChatTitle">Özel Sohbet</strong>
        <small id="rolePrivateChatStatus">Admin özel sohbeti</small>
      </div>
      <button type="button" onclick="closeRolePrivateChatView()">×</button>
    </div>
    <div id="rolePrivateChatMessages" class="role-private-chat-messages">
      <div class="comments-loading">Sohbet yükleniyor...</div>
    </div>
    <div class="role-private-chat-send">
      <textarea id="rolePrivateChatInput" placeholder="Kullanıcıya özel mesaj yaz..."></textarea>
      <button type="button" onclick="sendRolePrivateChatMessage()">Gönder</button>
      <button type="button" class="role-chat-close-danger" onclick="closeManagedPrivateChat()">Sohbeti Kapat</button>
    </div>
  `;
  document.body.appendChild(box);
  return box;
}

function renderRoleChatMessages(items = []) {
  const list = document.getElementById("rolePrivateChatMessages");
  if (!list) return;

  if (!items.length) {
    list.innerHTML = `<div class="support-empty">Henüz mesaj yok. İlk mesajı admin gönderebilir.</div>`;
    return;
  }

  list.innerHTML = items.map((item) => {
    const mine = item.fromUid === currentUser?.uid;
    const date = item.createdAt ? new Date(Number(item.createdAt)).toLocaleString("tr-TR") : "";
    return `
      <div class="role-chat-message ${mine ? "mine" : "other"}">
        <strong>${escapeHTML(item.fromName || (mine ? "Admin" : "Kullanıcı"))}</strong>
        <p>${escapeHTML(item.text || "")}</p>
        <small>${escapeHTML(date)}</small>
      </div>
    `;
  }).join("");

  list.scrollTop = list.scrollHeight;
}

function startRoleChatMessageListener(chatId) {
  stopRoleChatMessageListener();

  const list = document.getElementById("rolePrivateChatMessages");
  if (list) list.innerHTML = `<div class="comments-loading">Sohbet yükleniyor...</div>`;

  const msgQuery = query(
    collection(db, "privateChats", chatId, "messages"),
    orderBy("createdAt", "asc")
  );

  unsubscribeRoleChatMessages = onSnapshot(
    msgQuery,
    (snapshot) => {
      const items = snapshot.docs.map((item) => ({ id: item.id, ...item.data() }));
      renderRoleChatMessages(items);
    },
    (err) => {
      console.error("Özel sohbet mesajları okunamadı:", err);
      if (list) list.innerHTML = `<div class="support-empty">Mesajlar yüklenemedi: ${escapeHTML(err.message)}</div>`;
    }
  );
}

async function createRoleNotification(toUid, data = {}) {
  if (!toUid) return;

  try {
    await addDoc(collection(db, "notifications"), {
      toUid,
      fromUid: currentUser?.uid || "",
      fromUsername: currentAdminName(),
      type: data.type || "private_chat",
      title: data.title || "Admin özel sohbet açtı",
      message: data.message || "Admin seninle özel sohbet başlattı.",
      privateChatId: data.privateChatId || "",
      read: false,
      createdAt: Date.now()
    });
  } catch (err) {
    console.warn("Özel sohbet bildirimi oluşturulamadı:", err);
  }
}

async function deletePrivateChatMessages(chatId) {
  const snap = await getDocs(collection(db, "privateChats", chatId, "messages"));
  await Promise.all(snap.docs.map((item) => deleteDoc(item.ref)));
}


function getPanel() {
  return document.getElementById("rolePanel");
}

function setRoleButtonClick() {
  const rolesNavBtn = document.getElementById("rolesNavBtn");
  if (!rolesNavBtn) return;

  rolesNavBtn.hidden = true;
  rolesNavBtn.style.display = "none";
  rolesNavBtn.setAttribute("aria-hidden", "true");
}

function setSectionVisible(sectionName) {
  if (typeof window.showSection === "function") {
    window.showSection(sectionName);
    return;
  }

  const sections = {
    home: document.getElementById("homeSection"),
    profile: document.getElementById("profileSection"),
    customize: document.getElementById("customizeSection"),
    admin: document.getElementById("adminSection"),
    roles: document.getElementById("rolesSection"),
    gameDetail: document.getElementById("gameDetailSection")
  };

  Object.keys(sections).forEach((key) => {
    if (sections[key]) sections[key].style.display = key === sectionName ? "block" : "none";
  });

  window.__currentSectionName = sectionName;
}

function isCurrentAdmin() {
  return normalizeRole(currentRole) === "admin" || normalizeRole(window.currentRole) === "admin";
}

async function readCurrentUserRole() {
  currentUser = auth.currentUser || currentUser || null;

  if (!currentUser) {
    currentRole = "guest";
    currentUserData = null;
    return null;
  }

  const snap = await getDoc(doc(db, "users", currentUser.uid));
  currentUserData = snap.exists() ? snap.data() : null;

  if (currentUserData?.banned === true || currentUserData?.status === "banned") {
    currentRole = "banned";
    window.currentRole = "banned";
    return currentUserData;
  }

  currentRole = normalizeRole(currentUserData?.role || window.currentRole || "user");
  window.currentRole = currentRole;
  return currentUserData;
}

async function fetchUsers(force = false) {
  const cacheFresh = allUsers.length > 0 && Date.now() - usersLoadedAt < USERS_CACHE_TTL;

  if (!force && cacheFresh) {
    return allUsers;
  }

  if (roleLoadingPromise && !force) {
    return roleLoadingPromise;
  }

  roleLoadingPromise = (async () => {
    const snap = await getDocs(collection(db, "users"));
    const nextUsers = [];

    snap.forEach((item) => {
      const data = item.data();

      nextUsers.push({
        uid: item.id,
        ...data,
        role: normalizeRole(data?.role || "user")
      });
    });

    const seenUsers = new Set();
    allUsers = nextUsers.filter((user) => {
      const key = user.uid || user.id || user.email || JSON.stringify(user);
      if (seenUsers.has(key)) return false;
      seenUsers.add(key);
      return true;
    });
    usersLoadedAt = Date.now();
    return allUsers;
  })();

  try {
    return await roleLoadingPromise;
  } finally {
    roleLoadingPromise = null;
  }
}

function getFilteredUsers() {
  let users = [...allUsers];

  if (roleFilter === "banned") {
    users = users.filter((user) => isBanned(user));
  } else if (roleFilter !== "all") {
    users = users.filter((user) => !isBanned(user) && normalizeRole(user.role) === roleFilter);
  }

  const search = String(roleSearchText || "").trim().toLocaleLowerCase("tr-TR");
  if (search) {
    users = users.filter((user) => {
      const haystack = [
        user.username,
        user.displayName,
        user.firstName,
        user.lastName,
        `${user.firstName || ""} ${user.lastName || ""}`,
        user.email,
        user.uid
      ].filter(Boolean).join(" ").toLocaleLowerCase("tr-TR");
      return haystack.includes(search);
    });
  }

  users.sort((a, b) => {
    if (isBanned(a) !== isBanned(b)) return isBanned(a) ? 1 : -1;
    return displayName(a).localeCompare(displayName(b), "tr");
  });

  return users;
}

function renderEmpty(message, details = "") {
  const panel = getPanel();
  if (!panel) return;

  panel.innerHTML = `
    <div class="role-admin-empty">
      <h2>Rol Yönetimi</h2>
      <p>${escapeHTML(message)}</p>
      ${details ? `<small>${escapeHTML(details)}</small>` : ""}
      <br><br>
      <button type="button" onclick="loadRoleManagement(true)">Tekrar Dene</button>
    </div>
  `;
}

function renderRolePanel() {
  const panel = getPanel();
  if (!panel) return;

  if (!currentUser) {
    renderEmpty("Rol yönetimi için önce giriş yapmalısın.");
    return;
  }

  if (!isCurrentAdmin()) {
    renderEmpty("Bu alan sadece admin kullanıcılar içindir.", `Mevcut rol: ${currentRole || window.currentRole || "bilinmiyor"}`);
    return;
  }

  const filteredUsers = getFilteredUsers();
  const totalPages = Math.max(1, Math.ceil(filteredUsers.length / usersPerPage));

  if (rolePage > totalPages) rolePage = totalPages;
  if (rolePage < 1) rolePage = 1;

  const start = (rolePage - 1) * usersPerPage;
  const pageUsers = filteredUsers.slice(start, start + usersPerPage);

  const userRows = pageUsers.map((user) => {
    const banned = isBanned(user);
    const active = isActiveUser(user);
    const role = normalizeRole(user.role);
    const isMe = currentUser && currentUser.uid === user.uid;
    const photo = user.photoURL || "";
    const name = escapeHTML(displayName(user));
    const email = escapeHTML(user.email || "E-posta yok");
    const uid = escapeAttr(user.uid);
    const activityText = active ? "Aktif" : "Aktif Değil";

    return `
      <div class="role-user-card ${banned ? "is-banned" : active ? "is-active" : "is-inactive"}">
        <div class="role-user-left">
          ${
            photo
              ? `<img class="role-user-avatar" src="${escapeAttr(photo)}" alt="${name}" referrerpolicy="no-referrer" onerror="this.style.display='none'; this.nextElementSibling.style.display='grid';"><span class="role-user-avatar-fallback" style="display:none;">${name.charAt(0).toUpperCase()}</span>`
              : `<span class="role-user-avatar-fallback">${name.charAt(0).toUpperCase()}</span>`
          }

          <div>
            <strong>${name}</strong>
            <p>${email}</p>
            <span class="role-user-badge ${banned ? "banned" : role}">${banned ? "BANLI" : roleLabel(role)}</span>
            <span class="role-activity-badge ${active ? "active" : "inactive"}">${activityText}</span>
          </div>
        </div>

        <div class="role-user-actions">
          <select id="managedRole-${uid}" name="managedRole-${uid}" ${banned ? "disabled" : ""} onchange="changeManagedUserRole('${uid}', this.value)">
            <option value="user" ${role === "user" ? "selected" : ""}>Standart Üye</option>
            <option value="supporter" ${role === "supporter" ? "selected" : ""}>Destek Üye</option>
            <option value="operator" ${role === "operator" ? "selected" : ""}>Operatör</option>
            <option value="admin" ${role === "admin" ? "selected" : ""}>Admin</option>
          </select>

          ${
            banned
              ? `<button type="button" class="role-unban-btn" onclick="unbanManagedUser('${uid}')">Banı Kaldır</button>`
              : `<button type="button" class="role-ban-btn" ${isMe ? "disabled title='Kendi hesabını banlayamazsın'" : ""} onclick="banManagedUser('${uid}')">Kullanıcıyı Banla</button>`
          }

          <button type="button" class="role-chat-btn" ${isMe ? "disabled title='Kendinle sohbet açamazsın'" : ""} onclick="openManagedPrivateChat('${uid}')">Özel Sohbet</button>
        </div>
      </div>
    `;
  }).join("");

  let paginationHTML = "";
  if (totalPages > 1) {
    paginationHTML = `<div class="role-pagination">`;

    for (let i = 1; i <= totalPages; i++) {
      paginationHTML += `<button type="button" class="${i === rolePage ? "active" : ""}" onclick="changeRolePage(${i})">${i}</button>`;
    }

    paginationHTML += `</div>`;
  }

  const cacheInfo = usersLoadedAt
    ? `Son yükleme: ${new Date(usersLoadedAt).toLocaleTimeString("tr-TR")}`
    : "Henüz yüklenmedi";

  panel.innerHTML = `
    <div class="role-admin-head">
      <div>
        <h2>Rol Yönetimi</h2>
        <p>Liste 60 saniye önbellekte tutulur. Böylece panel her açıldığında tekrar geç yüklenmez.</p>
        <small>${escapeHTML(cacheInfo)}</small>
      </div>

      <div class="role-filter-box">
        <label for="roleUserSearchInput">Kullanıcı Ara</label>
        <input id="roleUserSearchInput" type="search" autocomplete="off" placeholder="Kullanıcı adı, ad, e-posta..." value="${escapeAttr(roleSearchText)}" oninput="changeRoleSearch(this.value)">
        <label for="roleFilterSelect">Rol Filtresi</label>
        <select id="roleFilterSelect" name="roleFilterSelect" autocomplete="off" onchange="changeRoleFilter(this.value)">
          <option value="all" ${roleFilter === "all" ? "selected" : ""}>Tüm Kullanıcılar</option>
          <option value="user" ${roleFilter === "user" ? "selected" : ""}>Standart Üye</option>
          <option value="supporter" ${roleFilter === "supporter" ? "selected" : ""}>Destek Üye</option>
          <option value="operator" ${roleFilter === "operator" ? "selected" : ""}>Operatör</option>
          <option value="admin" ${roleFilter === "admin" ? "selected" : ""}>Admin</option>
          <option value="banned" ${roleFilter === "banned" ? "selected" : ""}>Banlananlar</option>
        </select>

        <button type="button" onclick="loadRoleManagement(true)">Yenile</button>
      </div>
    </div>

    <div class="role-stats-row">
      <span>Toplam: ${allUsers.length}</span>
      <span>Gösterilen: ${filteredUsers.length}</span>
      <span>Sayfa: ${rolePage}/${totalPages}</span>
    </div>

    <div class="role-users-list">
      ${userRows || `<div class="role-admin-empty"><p>Bu filtrede kullanıcı bulunamadı.</p></div>`}
    </div>

    ${paginationHTML}
  `;
}

window.loadRoleManagement = async function (force = false) {
  const requestId = ++roleRenderRequestId;
  const panel = getPanel();
  if (!panel) return;

  currentUser = auth.currentUser || currentUser || null;

  const hasUsableCache = !force && allUsers.length > 0 && Date.now() - usersLoadedAt < USERS_CACHE_TTL;

  if (!hasUsableCache) {
    panel.innerHTML = `
      <div class="comments-loading">
        <span class="loader-dot"></span>
        Rol yönetimi yükleniyor...
      </div>
    `;
  }

  try {
    await readCurrentUserRole();
    if (requestId !== roleRenderRequestId) return;

    if (!currentUser || !isCurrentAdmin()) {
      renderRolePanel();
      return;
    }

    await fetchUsers(force);
    if (requestId !== roleRenderRequestId) return;
    renderRolePanel();
  } catch (err) {
    console.error("Rol yönetimi yüklenemedi:", err);
    panel.innerHTML = `
      <div class="comment-notice error">
        <h3>Rol yönetimi yüklenemedi</h3>
        <p>${escapeHTML(err.message || "Bilinmeyen hata")}</p>
        <p>Firestore Rules içinde <b>users</b> koleksiyonu için <b>allow read: if signedIn();</b> olmalı.</p>
        <button type="button" onclick="loadRoleManagement(true)">Tekrar Dene</button>
      </div>
    `;
  }
};

window.changeRoleSearch = function (value) {
  roleSearchText = String(value || "");
  rolePage = 1;
  renderRolePanel();

  requestAnimationFrame(() => {
    const input = document.getElementById("roleUserSearchInput");
    if (!input) return;
    input.focus();
    const end = input.value.length;
    try { input.setSelectionRange(end, end); } catch (_) {}
  });
};

window.changeRoleFilter = function (newFilter) {
  roleFilter = newFilter || "all";
  rolePage = 1;
  renderRolePanel();
};

window.changeRolePage = function (page) {
  rolePage = Number(page) || 1;
  renderRolePanel();
  const panel = getPanel();
  if (panel) panel.scrollIntoView({ behavior: "smooth", block: "start" });
};

window.changeManagedUserRole = async function (uid, newRole) {
  if (!currentUser || !isCurrentAdmin()) {
    notify("Bu işlem için admin olmalısın.", "error");
    return;
  }

  const role = normalizeRole(newRole);

  try {
    await updateDoc(doc(db, "users", uid), {
      role,
      updatedAt: Date.now()
    });

    const user = allUsers.find((item) => item.uid === uid);
    if (user) {
      user.role = role;
      user.updatedAt = Date.now();
    }

    if (window.currentUserData && uid === currentUser?.uid) {
      window.currentUserData.role = role;
    }

    window.dispatchEvent(new CustomEvent("xbox:user-role-updated", {
      detail: { uid, role, updatedAt: Date.now() }
    }));

    renderRolePanel();
    notify("Rol güncellendi. Eski yorumlardaki rol etiketi de yenilendi.");
  } catch (err) {
    console.error("Rol güncellenemedi:", err);
    notify("Rol güncellenemedi: " + (err.message || "Bilinmeyen hata"), "error");
    await window.loadRoleManagement(true);
  }
};

window.banManagedUser = async function (uid) {
  if (!currentUser || !isCurrentAdmin()) {
    notify("Bu işlem için admin olmalısın.", "error");
    return;
  }

  if (uid === currentUser.uid) {
    notify("Kendi hesabını banlayamazsın.", "error");
    return;
  }

  const reason = prompt("Ban sebebini yaz. Kullanıcı giriş yapınca bu sebebi görecek:", "");
  if (reason === null) return;

  const cleanReason = chatPreviewReason(reason, "Kural ihlali nedeniyle banlandınız.");

  const ok = confirm(`Bu kullanıcı banlanacak.\n\nSebep: ${cleanReason}\n\nEmin misin?`);
  if (!ok) return;

  try {
    await updateDoc(doc(db, "users", uid), {
      banned: true,
      status: "banned",
      banReason: cleanReason,
      banMessage: cleanReason,
      bannedAt: Date.now(),
      bannedBy: currentUser.uid,
      bannedByName: currentAdminName(),
      updatedAt: Date.now()
    });

    const user = allUsers.find((item) => item.uid === uid);
    if (user) {
      user.banned = true;
      user.status = "banned";
      user.banReason = cleanReason;
      user.banMessage = cleanReason;
      user.bannedAt = Date.now();
      user.bannedBy = currentUser.uid;
      user.bannedByName = currentAdminName();
    }

    try {
      await createRoleNotification(uid, {
        type: "account_banned",
        title: "Hesabın banlandı",
        message: `Ban sebebi: ${cleanReason}`
      });
    } catch (_) {}

    renderRolePanel();
    notify("Kullanıcı banlandı ve ban sebebi kaydedildi.");
  } catch (err) {
    console.error("Kullanıcı banlanamadı:", err);
    notify("Kullanıcı banlanamadı: " + (err.message || "Bilinmeyen hata"), "error");
  }
};

window.unbanManagedUser = async function (uid) {
  if (!currentUser || !isCurrentAdmin()) {
    notify("Bu işlem için admin olmalısın.", "error");
    return;
  }

  try {
    await updateDoc(doc(db, "users", uid), {
      banned: false,
      status: "active",
      unbannedAt: Date.now(),
      unbannedBy: currentUser.uid,
      banReason: "",
      banMessage: "",
      updatedAt: Date.now()
    });

    const user = allUsers.find((item) => item.uid === uid);
    if (user) {
      user.banned = false;
      user.status = "active";
      user.unbannedAt = Date.now();
      user.unbannedBy = currentUser.uid;
      user.banReason = "";
      user.banMessage = "";
    }

    renderRolePanel();
    notify("Kullanıcının banı kaldırıldı.");
  } catch (err) {
    console.error("Ban kaldırılamadı:", err);
    notify("Ban kaldırılamadı: " + (err.message || "Bilinmeyen hata"), "error");
  }
};


window.openManagedPrivateChat = async function(uid) {
  if (!currentUser || !isCurrentAdmin()) {
    notify("Bu işlem için admin olmalısın.", "error");
    return;
  }

  if (!uid || uid === currentUser.uid) return;

  const target = allUsers.find((item) => item.uid === uid);
  const chatId = roleChatId(currentUser.uid, uid);
  const targetName = displayName(target || { uid });

  try {
    await setDoc(doc(db, "privateChats", chatId), {
      chatId,
      adminUid: currentUser.uid,
      adminName: currentAdminName(),
      userUid: uid,
      userName: targetName,
      participants: [currentUser.uid, uid],
      status: "open",
      openedAt: Date.now(),
      updatedAt: Date.now(),
      lastMessage: "Admin özel sohbet açtı.",
      lastMessageAt: Date.now(),
      unreadForAdmin: false,
      unreadForUser: true
    }, { merge: true });

    window.dispatchEvent(new CustomEvent("xbox:private-chat-opened", {
      detail: {
        id: chatId,
        chatId,
        adminUid: currentUser.uid,
        adminName: currentAdminName(),
        userUid: uid,
        userName: targetName,
        participants: [currentUser.uid, uid],
        status: "open",
        openedAt: Date.now(),
        updatedAt: Date.now(),
        lastMessage: "Admin özel sohbet açtı.",
        lastMessageAt: Date.now(),
        unreadForAdmin: false,
        unreadForUser: true
      }
    }));

    await createRoleNotification(uid, {
      type: "private_chat_opened",
      title: "Admin özel sohbet açtı",
      message: `${currentAdminName()} seninle özel sohbet başlattı.`,
      privateChatId: chatId
    });

    activeRoleChatId = "";
    activeRoleChatUser = null;
    stopRoleChatMessageListener();

    const oldRightBox = document.getElementById("rolePrivateChatBox");
    if (oldRightBox) oldRightBox.classList.add("hidden");

    // v82: Rol yönetimindeki sağ sohbet penceresi açılmaz.
    // Sohbet sadece soldaki genel özel sohbet panelinden yönetilir.
    setTimeout(() => {
      if (window.togglePrivateChatPanel) {
        window.togglePrivateChatPanel(true);
      }
    }, 120);

    notify("Özel sohbet açıldı. Kullanıcıya bildirim gönderildi.");
  } catch (err) {
    console.error("Özel sohbet açılamadı:", err);
    notify("Özel sohbet açılamadı: " + (err.message || "Bilinmeyen hata"), "error");
  }
};

window.closeRolePrivateChatView = function() {
  stopRoleChatMessageListener();
  activeRoleChatId = "";
  activeRoleChatUser = null;
  const box = document.getElementById("rolePrivateChatBox");
  if (box) box.classList.add("hidden");
};

window.sendRolePrivateChatMessage = async function() {
  if (!activeRoleChatId || !currentUser || !isCurrentAdmin()) return;

  const input = document.getElementById("rolePrivateChatInput");
  const text = String(input?.value || "").trim();

  if (text.length < 1) {
    notify("Mesaj boş olamaz.", "error");
    return;
  }

  try {
    await addDoc(collection(db, "privateChats", activeRoleChatId, "messages"), {
      fromUid: currentUser.uid,
      fromName: currentAdminName(),
      text,
      createdAt: Date.now()
    });

    await updateDoc(doc(db, "privateChats", activeRoleChatId), {
      lastMessage: text.slice(0, 160),
      lastMessageAt: Date.now(),
      updatedAt: Date.now(),
      unreadForUser: true
    });

    if (activeRoleChatUser?.uid) {
      await createRoleNotification(activeRoleChatUser.uid, {
        type: "private_chat_message",
        title: "Admin özel sohbet mesajı",
        message: text.slice(0, 160),
        privateChatId: activeRoleChatId
      });
    }

    if (input) input.value = "";
  } catch (err) {
    console.error("Özel sohbet mesajı gönderilemedi:", err);
    notify("Mesaj gönderilemedi: " + (err.message || "Bilinmeyen hata"), "error");
  }
};

window.closeManagedPrivateChat = async function() {
  if (!activeRoleChatId || !currentUser || !isCurrentAdmin()) return;

  const ok = confirm("Bu özel sohbet kapatılacak ve sohbet mesajları Firebase'den silinecek. Emin misin?");
  if (!ok) return;

  const chatId = activeRoleChatId;
  const userUid = activeRoleChatUser?.uid || "";

  try {
    stopRoleChatMessageListener();
    await deletePrivateChatMessages(chatId);
    await deleteDoc(doc(db, "privateChats", chatId));

    if (userUid) {
      await createRoleNotification(userUid, {
        type: "private_chat_closed",
        title: "Özel sohbet kapatıldı",
        message: "Admin özel sohbeti kapattı. Sohbet mesajları Firebase'de tutulmadı.",
        privateChatId: chatId
      });
    }

    window.closeRolePrivateChatView();
    notify("Özel sohbet kapatıldı ve mesajlar Firebase'den silindi.");
  } catch (err) {
    console.error("Özel sohbet kapatılamadı:", err);
    notify("Sohbet kapatılamadı: " + (err.message || "Bilinmeyen hata"), "error");
  }
};


window.openRoleManagement = function () {
  setSectionVisible("admin");

  setTimeout(() => {
    if (typeof window.openAdminTab === "function") {
      window.openAdminTab("roles");
    } else {
      window.loadRoleManagement();
    }
  }, 30);
};

function patchShowSection() {
  if (window.__rolesShowSectionPatched) return;
  if (typeof window.showSection !== "function") return;

  window.__rolesShowSectionPatched = true;
  const originalShowSection = window.showSection;

  window.showSection = function (sectionName) {
    originalShowSection(sectionName);

    if (sectionName === "admin" && window.__activeAdminTab === "roles") {
      setTimeout(() => window.loadRoleManagement(), 80);
    }
  };
}

onAuthStateChanged(auth, async (user) => {
  currentUser = user || null;

  try {
    await readCurrentUserRole();
  } catch (err) {
    console.warn("Rol bilgisi alınamadı:", err);
  }

  setRoleButtonClick();
  patchShowSection();

  if (window.__currentSectionName === "admin" && window.__activeAdminTab === "roles") {
    setTimeout(() => window.loadRoleManagement(), 100);
  }
});

setRoleButtonClick();
patchShowSection();

window.addEventListener("load", () => {
  setRoleButtonClick();
  patchShowSection();

  if (window.__currentSectionName === "admin" && window.__activeAdminTab === "roles") {
    setTimeout(() => window.loadRoleManagement(), 100);
  }
});