export interface Env {
  GLADOS_COOKIE: string;
  TELEGRAM_BOT_TOKEN?: string;
  TELEGRAM_CHAT_ID?: string;
  GLADOS_EXCHANGE_PLAN?: "plan100" | "plan200" | "plan500" | "";
}

type GladosJson = Record<string, any>;

const GLADOS_DOMAINS = [
  "https://glados.cloud",
  "https://railgun.info",
  "https://glados.rocks",
  "https://glados.network"
];

const EXCHANGE_PLANS: Record<string, { points: number; days: number }> = {
  plan100: { points: 100, days: 7 },
  plan200: { points: 200, days: 15 },
  plan500: { points: 500, days: 40 }
};

export default {
  async fetch(_request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    ctx.waitUntil(run(env));

    return new Response("GLaDOS check-in started. Check Telegram or Worker logs.", {
      headers: {
        "content-type": "text/plain;charset=UTF-8"
      }
    });
  },

  async scheduled(_controller: ScheduledController, env: Env, ctx: ExecutionContext): Promise<void> {
    ctx.waitUntil(run(env));
  }
};

async function run(env: Env): Promise<void> {
  const cookies = parseCookies(env.GLADOS_COOKIE);

  if (cookies.length === 0) {
    await notifyTelegram(env, "❌ GLaDOS 签到失败：未配置 GLADOS_COOKIE");
    return;
  }

  const reports: string[] = [];
  let successCount = 0;

  for (let i = 0; i < cookies.length; i++) {
    const cookie = cookies[i];
    const accountNo = i + 1;

    try {
      const report = await checkOneAccount(
        cookie,
        accountNo,
        env.GLADOS_EXCHANGE_PLAN || ""
      );

      reports.push(report.text);

      if (report.success) {
        successCount++;
      }

      console.log(report.text);
    } catch (error) {
      reports.push(
        `👤 账号 ${accountNo}\n` +
        `状态：❌ 异常\n` +
        `错误：${safeError(error)}`
      );
    }
  }

  const title = `🎉 GLaDOS 签到完成：${successCount}/${cookies.length}`;

  const message =
    `<b>${escapeHtml(title)}</b>\n\n` +
    reports.map(escapeHtml).join("\n\n");

  console.log(stripHtml(message));

  await notifyTelegram(env, message);
}

async function checkOneAccount(
  cookie: string,
  accountNo: number,
  exchangePlan: string
): Promise<{ success: boolean; text: string }> {
  const beforeStatus = await gladosRequest(cookie, "GET", "/api/user/status");
  const beforePoints = await gladosRequest(cookie, "GET", "/api/user/points");

  const checkin = await gladosRequest(cookie, "POST", "/api/user/checkin", {
    token: "glados.cloud"
  });

  const afterStatus = await gladosRequest(cookie, "GET", "/api/user/status");
  const afterPoints = await gladosRequest(cookie, "GET", "/api/user/points");

  const email =
    getString(afterStatus, ["data", "email"]) ||
    getString(beforeStatus, ["data", "email"]) ||
    "未知";

  const leftDays = getNumber(afterStatus, ["data", "leftDays"]);
  const checkinMessage = getString(checkin, ["message"]) || JSON.stringify(checkin);

  const beforePoint = extractPoints(beforePoints);
  const afterPoint = extractPoints(afterPoints);

  const diff =
    beforePoint !== null && afterPoint !== null
      ? afterPoint - beforePoint
      : null;

  const success = isCheckinSuccess(checkinMessage);

  let exchangeText = "";

  if (exchangePlan && EXCHANGE_PLANS[exchangePlan]) {
    exchangeText = await tryExchange(cookie, exchangePlan, afterPoint);
  }

  const lines = [
    `👤 账号 ${accountNo}`,
    `📧 邮箱：${email}`,
    `📝 签到：${success ? "✅" : "⚠️"} ${checkinMessage}`,
    `📅 剩余天数：${leftDays === null ? "未知" : leftDays.toFixed(2)}`,
    `💎 积分：${afterPoint === null ? "未知" : afterPoint}`,
    `📈 今日积分变化：${diff === null ? "未知" : diff >= 0 ? `+${diff}` : `${diff}`}`
  ];

  if (exchangeText) {
    lines.push(exchangeText);
  }

  return {
    success,
    text: lines.join("\n")
  };
}

async function gladosRequest(
  cookie: string,
  method: "GET" | "POST",
  path: string,
  body?: unknown
): Promise<GladosJson | null> {
  let lastError = "";

  for (const domain of GLADOS_DOMAINS) {
    try {
      const response = await fetch(domain + path, {
        method,
        headers: {
          "User-Agent": "Mozilla/5.0",
          "Accept": "application/json, text/plain, */*",
          "Content-Type": "application/json;charset=UTF-8",
          "Cookie": cookie,
          "Origin": domain,
          "Referer": `${domain}/console/checkin`
        },
        body: body === undefined ? undefined : JSON.stringify(body)
      });

      const text = await response.text();

      if (!response.ok) {
        lastError = `${domain} HTTP ${response.status}: ${text.slice(0, 200)}`;
        continue;
      }

      try {
        return JSON.parse(text);
      } catch {
        return {
          raw: text
        };
      }
    } catch (error) {
      lastError = `${domain}: ${safeError(error)}`;
    }
  }

  return {
    message: `Network Error: ${lastError || "all domains failed"}`
  };
}

async function tryExchange(
  cookie: string,
  plan: string,
  currentPoints: number | null
): Promise<string> {
  const config = EXCHANGE_PLANS[plan];

  if (!config) {
    return "";
  }

  if (currentPoints === null) {
    return "🎁 自动兑换：跳过，无法读取积分";
  }

  if (currentPoints < config.points) {
    return `🎁 自动兑换：积分不足，${currentPoints}/${config.points}`;
  }

  const result = await gladosRequest(cookie, "POST", "/api/user/points", {
    action: "exchange",
    point: config.points
  });

  const message = getString(result, ["message"]) || JSON.stringify(result);

  return `🎁 自动兑换：${plan}，${message}`;
}

async function notifyTelegram(env: Env, html: string): Promise<void> {
  const token = env.TELEGRAM_BOT_TOKEN;
  const chatId = env.TELEGRAM_CHAT_ID;

  if (!token || !chatId) {
    console.log(stripHtml(html));
    return;
  }

  const response = await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      chat_id: chatId,
      text: html,
      parse_mode: "HTML",
      disable_web_page_preview: true
    })
  });

  if (!response.ok) {
    const text = await response.text();
    console.log(`Telegram send failed: ${response.status} ${text}`);
  }
}

function parseCookies(raw: string | undefined): string[] {
  if (!raw) {
    return [];
  }

  return raw
    .split(/\n|&/)
    .map((item) => item.trim())
    .filter(Boolean);
}

function isCheckinSuccess(message: string): boolean {
  const normalized = message.toLowerCase();

  return (
    normalized.includes("checkin") ||
    normalized.includes("checked") ||
    normalized.includes("already") ||
    normalized.includes("observation") ||
    message.includes("签到") ||
    message.includes("已签到")
  );
}

function extractPoints(json: GladosJson | null): number | null {
  if (!json) {
    return null;
  }

  const candidates = [
    json.points,
    json.point,
    json.data?.points,
    json.data?.point,
    json.data?.balance,
    json.data?.credit
  ];

  for (const value of candidates) {
    const num = Number(value);

    if (Number.isFinite(num)) {
      return num;
    }
  }

  return null;
}

function getString(obj: any, path: string[]): string | null {
  let cur = obj;

  for (const key of path) {
    cur = cur?.[key];
  }

  return typeof cur === "string" ? cur : null;
}

function getNumber(obj: any, path: string[]): number | null {
  let cur = obj;

  for (const key of path) {
    cur = cur?.[key];
  }

  const num = Number(cur);

  return Number.isFinite(num) ? num : null;
}

function safeError(error: unknown): string {
  if (error instanceof Error) {
    return error.message;
  }

  return String(error);
}

function escapeHtml(input: string): string {
  return input
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;");
}

function stripHtml(input: string): string {
  return input.replace(/<[^>]*>/g, "");
}