import React, { memo } from "react";

function LogsTab({
  logsTab,
  setLogsTab,
  taskNotice,
  hasSelectedTask,
  exportLogs,
  clearLogs,
  exportInvites,
  clearInvites,
  logSearch,
  setLogSearch,
  logPage,
  setLogPage,
  logPageCount,
  pagedLogs,
  inviteSearch,
  setInviteSearch,
  invitePage,
  setInvitePage,
  invitePageCount,
  inviteFilter,
  setInviteFilter,
  pagedInvites,
  formatTimestamp,
  explainInviteError,
  expandedInviteId,
  setExpandedInviteId
}) {
  const strategyLabel = (strategy) => {
    switch (strategy) {
      case "access_hash":
        return "access_hash (из сообщения)";
      case "participants":
        return "участники группы";
      case "username":
        return "username";
      case "entity":
        return "getEntity(userId)";
      case "retry":
        return "повторная попытка";
      default:
        return strategy || "—";
    }
  };

  const formatStrategies = (meta) => {
    if (!meta) return "";
    try {
      const parsed = JSON.parse(meta);
      if (!Array.isArray(parsed)) return meta;
      return parsed
        .map((item) => `${strategyLabel(item.strategy)}: ${item.ok ? "ok" : "fail"}${item.detail ? ` (${item.detail})` : ""}`)
        .map((line) => `- ${line}`)
        .join("\n");
    } catch (error) {
      return meta;
    }
  };

  const hasStrategySuccess = (meta) => {
    if (!meta) return false;
    try {
      const parsed = JSON.parse(meta);
      return Array.isArray(parsed) && parsed.some((item) => item.ok);
    } catch (error) {
      return false;
    }
  };

  const formatTargetType = (value) => {
    if (!value) return "—";
    if (value === "channel") return "канал";
    if (value === "megagroup") return "супергруппа";
    if (value === "group") return "группа";
    return value;
  };

  const getDurationMs = (start, finish) => {
    const startMs = new Date(start).getTime();
    const finishMs = new Date(finish).getTime();
    if (!Number.isFinite(startMs) || !Number.isFinite(finishMs)) return null;
    return Math.max(0, finishMs - startMs);
  };

  return (
    <section className="card logs">
      <div className="row-header">
        <h2>Логи и история</h2>
        <div className="row-inline">
          {logsTab === "logs" ? (
            <>
              <button className="secondary" onClick={() => exportLogs("logs")} disabled={!hasSelectedTask}>Выгрузить</button>
              <button className="danger" onClick={() => clearLogs("logs")} disabled={!hasSelectedTask}>Сбросить</button>
            </>
          ) : (
            <>
              <button className="secondary" onClick={() => exportInvites("invites")} disabled={!hasSelectedTask}>Выгрузить</button>
              <button className="danger" onClick={() => clearInvites("invites")} disabled={!hasSelectedTask}>Сбросить</button>
            </>
          )}
        </div>
      </div>
      <div className="log-tabs">
        <button
          type="button"
          className={`tab ${logsTab === "logs" ? "active" : ""}`}
          onClick={() => setLogsTab("logs")}
        >
          Логи
        </button>
        <button
          type="button"
          className={`tab ${logsTab === "invites" ? "active" : ""}`}
          onClick={() => setLogsTab("invites")}
        >
          История инвайтов
        </button>
      </div>
      {taskNotice && (taskNotice.source === "logs" || taskNotice.source === "invites") && (
        <div className={`notice inline ${taskNotice.tone}`}>{taskNotice.text}</div>
      )}
      {logsTab === "logs" && (
        <>
          <div className="row-inline">
            <input
              type="text"
              value={logSearch}
              onChange={(event) => {
                setLogSearch(event.target.value);
                setLogPage(1);
              }}
              placeholder="Поиск по логам"
            />
            <div className="pager">
              <button
                className="secondary"
                type="button"
                onClick={() => setLogPage((prev) => Math.max(1, prev - 1))}
                disabled={logPage === 1}
              >
                Назад
              </button>
              <span>{logPage}/{logPageCount}</span>
              <button
                className="secondary"
                type="button"
                onClick={() => setLogPage((prev) => Math.min(logPageCount, prev + 1))}
                disabled={logPage === logPageCount}
              >
                Вперед
              </button>
            </div>
          </div>
          {pagedLogs.length === 0 && <div className="empty">Логи пока пустые.</div>}
          {pagedLogs.map((log) => {
            const successIds = Array.isArray(log.successIds) ? log.successIds : [];
            const errors = Array.isArray(log.errors) ? log.errors : [];
            const errorMap = new Map();
            errors.forEach((err) => {
              const parts = String(err).split(":");
              if (parts.length < 2) return;
              const id = parts[0].trim();
              const code = parts.slice(1).join(":").trim();
              if (!id) return;
              errorMap.set(id, code);
            });
            const resultRows = [
              ...successIds.map((id) => ({
                id: String(id),
                status: "success",
                message: "успех"
              })),
              ...Array.from(errorMap.entries()).map(([id, code]) => ({
                id,
                status: "error",
                message: `${code} (${explainInviteError(code) || "Причина не определена"})`
              }))
            ];
            return (
              <div key={log.id} className="log-row">
                <div className="log-time">
                  <div>Старт цикла: {formatTimestamp(log.startedAt)}</div>
                  <div>Завершение: {formatTimestamp(log.finishedAt)}</div>
                </div>
                <div className="log-details">
                  <div>Добавлено: {log.invitedCount}</div>
                  <div className="log-users wrap">
                    Пользователи: {successIds.length ? successIds.join(", ") : "—"}
                  </div>
                  {resultRows.length > 0 && (
                    <div className="log-users">
                      <div>Результаты:</div>
                      <div className="log-result-list">
                        {resultRows.map((row) => (
                          <div key={`${log.id}-${row.id}-${row.status}`} className={`log-result ${row.status}`}>
                            {row.id} — {row.message}
                          </div>
                        ))}
                      </div>
                    </div>
                  )}
                  {log.invitedCount === 0 && errors.length === 0 && (
                    <div className="log-errors">Причина: цикл завершён сразу — очередь пуста</div>
                  )}
                  {errors.length > 0 && (
                    <div className="log-errors">
                      Ошибки: {errors.map((err) => {
                        const code = String(err).split(":").pop().trim();
                        const reason = explainInviteError(code) || "Причина не определена";
                        return code ? `${err} (${reason})` : err;
                      }).join(" | ")}
                    </div>
                  )}
                  {(() => {
                    const durationMs = getDurationMs(log.startedAt, log.finishedAt);
                    if (durationMs != null && durationMs < 1000) {
                      return <div className="log-errors">Цикл завершён сразу: очередь пуста или ошибка на первой попытке.</div>;
                    }
                    return null;
                  })()}
                </div>
              </div>
            );
          })}
        </>
      )}
      {logsTab === "invites" && (
        <>
          <div className="row-inline">
            <input
              type="text"
              value={inviteSearch}
              onChange={(event) => {
                setInviteSearch(event.target.value);
                setInvitePage(1);
              }}
              placeholder="Поиск по инвайтам"
            />
            <div className="pager">
              <button
                className="secondary"
                type="button"
                onClick={() => setInvitePage((prev) => Math.max(1, prev - 1))}
                disabled={invitePage === 1}
              >
                Назад
              </button>
              <span>{invitePage}/{invitePageCount}</span>
              <button
                className="secondary"
                type="button"
                onClick={() => setInvitePage((prev) => Math.min(invitePageCount, prev + 1))}
                disabled={invitePage === invitePageCount}
              >
                Вперед
              </button>
            </div>
          </div>
          <div className="task-filters">
            <button
              type="button"
              className={`chip ${inviteFilter === "all" ? "active" : ""}`}
              onClick={() => {
                setInviteFilter("all");
                setInvitePage(1);
              }}
            >
              Все
            </button>
            <button
              type="button"
              className={`chip ${inviteFilter === "success" ? "active" : ""}`}
              onClick={() => {
                setInviteFilter("success");
                setInvitePage(1);
              }}
            >
              Успех
            </button>
            <button
              type="button"
              className={`chip ${inviteFilter === "error" ? "active" : ""}`}
              onClick={() => {
                setInviteFilter("error");
                setInvitePage(1);
              }}
            >
              Ошибка
            </button>
            <button
              type="button"
              className={`chip ${inviteFilter === "skipped" ? "active" : ""}`}
              onClick={() => {
                setInviteFilter("skipped");
                setInvitePage(1);
              }}
            >
              Пропуск
            </button>
          </div>
          {pagedInvites.length === 0 && <div className="empty">История пока пустая.</div>}
          {pagedInvites.map((invite) => (
            <div key={invite.id} className="log-row">
              <div className="log-time">
                <div>{formatTimestamp(invite.invitedAt)}</div>
                <div>{invite.status === "success" ? "Успех" : "Ошибка"}</div>
              </div>
              <div className="log-details">
                <div>ID: {invite.userId}</div>
                <div className="log-users wrap">
                  Ник: {invite.username ? `@${invite.username}` : "—"}
                </div>
                <div className="log-users wrap">
                  Источник: {invite.sourceChat || "—"}
                </div>
                <div className="log-users wrap">
                  Цель: {invite.targetChat || "—"}{invite.targetType ? ` (${formatTargetType(invite.targetType)})` : ""}
                </div>
                <div className="log-users">
                  Инвайт: {invite.accountPhone || "—"}
                  {invite.watcherPhone && invite.accountPhone && (
                    <span className={`match-badge ${invite.watcherPhone === invite.accountPhone ? "ok" : "warn"}`}>
                      {invite.watcherPhone === invite.accountPhone
                        ? "Инвайт тем же аккаунтом, что наблюдал"
                        : "Инвайт другим аккаунтом (наблюдатель отличается)"}
                    </span>
                  )}
                </div>
                <div className="log-users">Наблюдатель: {invite.watcherPhone || "—"}</div>
                {invite.skippedReason && invite.skippedReason !== "" && (
                  <div className="log-errors">Пропуск: {invite.skippedReason}</div>
                )}
                {invite.error && invite.error !== "" && (
                  <div className="log-errors">Причина: {invite.error}</div>
                )}
                {invite.error && (
                  <div className="log-users">
                    Вероятная причина: {explainInviteError(invite.error) || "Причина не определена"}
                  </div>
                )}
                {invite.strategy && (
                  <div className="log-users">Стратегия: {invite.strategy}</div>
                )}
                {invite.strategyMeta && (
                  <div className="log-users">{`Стратегии:\n${formatStrategies(invite.strategyMeta)}`}</div>
                )}
                {invite.strategyMeta && !hasStrategySuccess(invite.strategyMeta) && (
                  <div className="log-errors">Все стратегии не сработали</div>
                )}
                <button
                  type="button"
                  className="ghost"
                  onClick={() => setExpandedInviteId(expandedInviteId === invite.id ? null : invite.id)}
                >
                  {expandedInviteId === invite.id ? "Скрыть детали" : "Подробнее"}
                </button>
                {expandedInviteId === invite.id && (
                  <div className="invite-details">
                    <div>Задача: {invite.taskId}</div>
                    <div>Аккаунт ID: {invite.accountId || "—"}</div>
                    <div>Наблюдатель ID: {invite.watcherAccountId || "—"}</div>
                    <div>Наблюдатель: {invite.watcherPhone || "—"}</div>
                    <div>Цель: {invite.targetChat || "—"}</div>
                    <div>Тип цели: {formatTargetType(invite.targetType)}</div>
                    <div>Действие: {invite.action || "invite"}</div>
                    <div>Статус: {invite.status}</div>
                    <div>Пропуск: {invite.skippedReason || "—"}</div>
                    <div>Ошибка: {invite.error || "—"}</div>
                    <div>Вероятная причина: {explainInviteError(invite.error) || "Причина не определена"}</div>
                    <div>Стратегия: {invite.strategy || "—"}</div>
                    <div className="pre-line">
                      {invite.strategyMeta ? `Стратегии:\n${formatStrategies(invite.strategyMeta)}` : "Стратегии: —"}
                    </div>
                    {invite.strategyMeta && !hasStrategySuccess(invite.strategyMeta) && (
                      <div>Результат: все стратегии не сработали</div>
                    )}
                    <div>Access Hash: {invite.userAccessHash || "—"}</div>
                    <div>Время: {formatTimestamp(invite.invitedAt)}</div>
                  </div>
                )}
              </div>
            </div>
          ))}
        </>
      )}
    </section>
  );
}

export default memo(LogsTab);
