import type { MethodInfo } from '../method-types.js';
import { SupportedLanguages, type ParameterTypeClass } from 'gitnexus-shared';

/** Languages where class overload signatures are declaration-only contracts
 *  that should collapse to the implementation body's node ID. */
const SKIP_TYPE_HASH_LANGUAGES: ReadonlySet<SupportedLanguages> = new Set([
  SupportedLanguages.TypeScript,
  SupportedLanguages.JavaScript,
]);

/**
 * Compute arity for ID-generation purposes.
 * Returns `undefined` when any parameter is variadic (arity is indeterminate).
 */
export function arityForIdFromInfo(info: MethodInfo): number | undefined {
  return info.parameters.some((p) => p.isVariadic) ? undefined : info.parameters.length;
}

/**
 * Compute a type-based discriminator suffix for same-arity overloads.
 * Returns `~type1,type2` when the current method collides with another method
 * in the same class that has the same name and arity but different parameter types.
 * Returns `''` when there is no collision or types are unavailable.
 */
/**
 * Build collision groups from a method map — groups methods by `name#arity`.
 * Call once per class, then pass to typeTagForId/constTagForId to avoid O(N²) scans.
 */
export function buildCollisionGroups(
  methodMap: Map<string, MethodInfo>,
): Map<string, MethodInfo[]> {
  const groups = new Map<string, MethodInfo[]>();
  for (const info of methodMap.values()) {
    if (info.parameters.some((p) => p.isVariadic)) continue;
    const key = `${info.name}#${info.parameters.length}`;
    let group = groups.get(key);
    if (!group) {
      group = [];
      groups.set(key, group);
    }
    group.push(info);
  }
  return groups;
}

export function typeTagForId(
  methodMap: Map<string, MethodInfo>,
  methodName: string,
  arity: number | undefined,
  currentInfo: MethodInfo,
  language?: SupportedLanguages,
  /** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
  collisionGroups?: Map<string, MethodInfo[]>,
): string {
  if (arity === undefined) return '';

  // Zero-arity methods have no parameter types to disambiguate.
  if (arity === 0) return '';

  // TS/JS class overload signatures are declaration-only contracts that should
  // collapse to the implementation body's node ID, not be disambiguated.
  if (language && SKIP_TYPE_HASH_LANGUAGES.has(language)) return '';

  // Check if all parameters of this method have types (rawType or type)
  if (
    currentInfo.parameters.length > 0 &&
    currentInfo.parameters.some((p) => (p.rawType ?? p.type) === null)
  ) {
    return '';
  }

  // Use pre-built collision group if available, otherwise scan (backward compat)
  const groupKey = `${methodName}#${arity}`;
  const sameArityGroup =
    collisionGroups?.get(groupKey) ?? _buildGroup(methodMap, methodName, arity);

  // No collision — single method with this name+arity
  if (sameArityGroup.length < 2) return '';

  // Check that ALL methods in the collision group have full type info
  for (const info of sameArityGroup) {
    if (info.parameters.length > 0 && info.parameters.some((p) => (p.rawType ?? p.type) === null)) {
      return '';
    }
  }

  // Build type tag from current method's parameter types.
  // Prefer rawType (preserves generic/template args like vector<int>) over
  // type (simplified by extractSimpleTypeName which strips generics).
  const types = currentInfo.parameters.map((p) => (p.rawType ?? p.type) as string);
  return `~${types.join(',')}`;
}

/** Fallback: build a same-arity group by scanning the full map (O(N)). */
function _buildGroup(
  methodMap: Map<string, MethodInfo>,
  methodName: string,
  arity: number,
): MethodInfo[] {
  const group: MethodInfo[] = [];
  for (const info of methodMap.values()) {
    if (info.name !== methodName) continue;
    if (info.parameters.some((p) => p.isVariadic)) continue;
    if (info.parameters.length !== arity) continue;
    group.push(info);
  }
  return group;
}

/**
 * Compute a const-qualifier suffix for C++ const/non-const method collisions.
 * Returns `$const` when the current method is const-qualified and a non-const
 * method with the same name and arity exists in the same class.
 * Returns `''` when there is no collision or the method is not const-qualified.
 */
export function constTagForId(
  methodMap: Map<string, MethodInfo>,
  methodName: string,
  arity: number | undefined,
  currentInfo: MethodInfo,
  /** Pre-built collision groups from buildCollisionGroups(). Avoids O(N) scan per call. */
  collisionGroups?: Map<string, MethodInfo[]>,
): string {
  if (!currentInfo.isConst) return '';
  if (arity === undefined) return '';

  // Use pre-built group if available
  const groupKey = `${methodName}#${arity}`;
  const group = collisionGroups?.get(groupKey);
  const candidates = group ?? _buildGroup(methodMap, methodName, arity);

  // Check if a non-const method exists in the collision group
  for (const info of candidates) {
    if (info === currentInfo) continue;
    if (info.isConst) continue;
    return '$const';
  }

  return '';
}

/**
 * Disambiguate function-template overloads whose normalized parameter types
 * intentionally collapse to the same placeholder token (`T`, `U`, ...), but
 * whose C++ sidecar shape is semantically different (`T` vs `T*` / `T&`).
 *
 * Kept intentionally narrow: concrete types already use the existing raw-type
 * overload tag, and non-template languages should not acquire sidecar-shaped
 * IDs.
 */
export function parameterShapeIdTag(
  parameterTypes?: readonly string[],
  parameterTypeClasses?: readonly ParameterTypeClass[],
): string {
  if (
    parameterTypes === undefined ||
    parameterTypeClasses === undefined ||
    parameterTypes.length === 0
  ) {
    return '';
  }
  let hasTemplatePlaceholder = false;
  let hasDisambiguatingShape = false;
  const parts: string[] = [];
  for (let i = 0; i < parameterTypes.length; i++) {
    const type = parameterTypes[i];
    const typeClass = parameterTypeClasses[i];
    if (typeClass === undefined) return '';
    if (/^[A-Z]\w*$/.test(type)) hasTemplatePlaceholder = true;
    if (
      typeClass.indirection !== 'value' ||
      typeClass.pointerDepth > 0 ||
      (typeClass.cv !== 'none' && typeClass.cv !== 'unknown')
    ) {
      hasDisambiguatingShape = true;
    }
    parts.push(
      `${type}:${typeClass.cv}:${typeClass.indirection}:${typeClass.pointerDepth.toString()}`,
    );
  }
  if (!hasTemplatePlaceholder || !hasDisambiguatingShape) return '';
  return `~shape:${parts.join('|')}`;
}

/** Convert MethodInfo from methodExtractor into flat properties for a graph node. */
export function buildMethodProps(info: MethodInfo): Record<string, unknown> {
  const types: string[] = [];
  const typeClasses: ParameterTypeClass[] = [];
  let optionalCount = 0;
  let hasVariadic = false;
  for (const p of info.parameters) {
    if (p.type !== null) types.push(p.type);
    if (p.typeClass !== undefined) typeClasses.push(p.typeClass);
    if (p.isOptional) optionalCount++;
    if (p.isVariadic) hasVariadic = true;
  }
  return {
    parameterCount: hasVariadic ? undefined : info.parameters.length,
    ...(!hasVariadic && optionalCount > 0
      ? { requiredParameterCount: info.parameters.length - optionalCount }
      : {}),
    ...(types.length > 0 ? { parameterTypes: types } : {}),
    ...(typeClasses.length === info.parameters.length && typeClasses.length > 0
      ? { parameterTypeClasses: typeClasses }
      : {}),
    returnType: info.returnType ?? undefined,
    visibility: info.visibility,
    isStatic: info.isStatic,
    isAbstract: info.isAbstract,
    isFinal: info.isFinal,
    ...(info.isVirtual ? { isVirtual: info.isVirtual } : {}),
    ...(info.isOverride ? { isOverride: info.isOverride } : {}),
    ...(info.isAsync ? { isAsync: info.isAsync } : {}),
    ...(info.isPartial ? { isPartial: info.isPartial } : {}),
    ...(info.isConst ? { isConst: info.isConst } : {}),
    ...(info.annotations.length > 0 ? { annotations: info.annotations } : {}),
  };
}
