import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk/feishu";
import type { FeishuConfig, FeishuGroupConfig } from "./types.js";

export type FeishuGroupCommandMentionBypass = "never" | "single_bot" | "always";

export type FeishuAllowlistMatch = {
  allowed: boolean;
  matchKey?: string;
  matchSource?: "wildcard" | "id" | "name";
};

export function resolveFeishuAllowlistMatch(params: {
  allowFrom: Array<string | number>;
  senderId: string;
  senderName?: string | null;
}): FeishuAllowlistMatch {
  const allowFrom = params.allowFrom
    .map((entry) => String(entry).trim().toLowerCase())
    .filter(Boolean);

  if (allowFrom.length === 0) return { allowed: false };
  if (allowFrom.includes("*")) {
    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
  }

  const senderId = params.senderId.toLowerCase();
  if (allowFrom.includes(senderId)) {
    return { allowed: true, matchKey: senderId, matchSource: "id" };
  }

  const senderName = params.senderName?.toLowerCase();
  if (senderName && allowFrom.includes(senderName)) {
    return { allowed: true, matchKey: senderName, matchSource: "name" };
  }

  return { allowed: false };
}

export function resolveFeishuGroupConfig(params: {
  cfg?: FeishuConfig;
  groupId?: string | null;
}): FeishuGroupConfig | undefined {
  const groups = params.cfg?.groups ?? {};
  const groupId = params.groupId?.trim();
  if (!groupId) return undefined;

  const direct = groups[groupId] as FeishuGroupConfig | undefined;
  if (direct) return direct;

  const lowered = groupId.toLowerCase();
  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
  return matchKey ? (groups[matchKey] as FeishuGroupConfig | undefined) : undefined;
}

export function resolveFeishuGroupToolPolicy(
  params: ChannelGroupContext,
): GroupToolPolicyConfig | undefined {
  const cfg = params.cfg.channels?.feishu as FeishuConfig | undefined;
  if (!cfg) return undefined;

  const groupConfig = resolveFeishuGroupConfig({
    cfg,
    groupId: params.groupId,
  });

  return groupConfig?.tools;
}

export function isFeishuGroupAllowed(params: {
  groupPolicy: "open" | "allowlist" | "disabled";
  allowFrom: Array<string | number>;
  senderId: string;
  senderName?: string | null;
}): boolean {
  const { groupPolicy } = params;
  if (groupPolicy === "disabled") return false;
  if (groupPolicy === "open") return true;
  return resolveFeishuAllowlistMatch(params).allowed;
}

export function resolveFeishuReplyPolicy(params: {
  isDirectMessage: boolean;
  globalConfig?: FeishuConfig;
  groupConfig?: FeishuGroupConfig;
}): { requireMention: boolean; allowMentionlessInMultiBotGroup: boolean } {
  if (params.isDirectMessage) {
    return { requireMention: false, allowMentionlessInMultiBotGroup: false };
  }

  const requireMention =
    params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? true;
  const allowMentionlessInMultiBotGroup =
    params.groupConfig?.allowMentionlessInMultiBotGroup ??
    params.globalConfig?.allowMentionlessInMultiBotGroup ??
    false;

  return { requireMention, allowMentionlessInMultiBotGroup };
}

export function resolveFeishuGroupCommandMentionBypass(params: {
  globalConfig?: FeishuConfig;
  groupConfig?: FeishuGroupConfig;
}): FeishuGroupCommandMentionBypass {
  return (
    params.groupConfig?.groupCommandMentionBypass ??
    params.globalConfig?.groupCommandMentionBypass ??
    "single_bot"
  );
}