import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import type { Node, Language } from '../src/types';
import type { ResolutionContext, UnresolvedRef } from '../src/resolution/types';
import { reactNativeBridgeResolver } from '../src/resolution/frameworks/react-native';
import { CodeGraph } from '../src';

/**
 * Mock ResolutionContext for the React Native bridge resolver.
 */
function makeContext(nodes: Node[], fileContents: Record<string, string> = {}): ResolutionContext {
  const byName = new Map<string, Node[]>();
  for (const n of nodes) {
    const arr = byName.get(n.name);
    if (arr) arr.push(n);
    else byName.set(n.name, [n]);
  }
  // Files = union of node files + any extra fileContents keys (for files that
  // have content like .mm bridge declarations but no extracted nodes yet).
  const allFiles = new Set<string>(
    [...nodes.map((n) => n.filePath), ...Object.keys(fileContents)]
  );
  return {
    getNodesInFile: (fp) => nodes.filter((n) => n.filePath === fp),
    getNodesByName: (name) => byName.get(name) ?? [],
    getNodesByQualifiedName: () => { throw new Error('not used'); },
    getNodesByKind: (kind) => nodes.filter((n) => n.kind === kind),
    getNodesByLowerName: () => { throw new Error('not used'); },
    fileExists: (fp) => allFiles.has(fp),
    readFile: (fp) => fileContents[fp] ?? null,
    getProjectRoot: () => '/test',
    getAllFiles: () => Array.from(allFiles),
    getImportMappings: () => [],
  };
}

function method(
  name: string,
  language: Language,
  filePath: string,
  startLine = 10
): Node {
  return {
    id: `${language}:${filePath}:${name}:${startLine}`,
    kind: 'method',
    name,
    qualifiedName: `${filePath}::${name}`,
    filePath,
    language,
    startLine,
    endLine: startLine + 5,
    startColumn: 0,
    endColumn: 0,
    updatedAt: Date.now(),
  } as Node;
}

function ref(name: string, language: Language, filePath: string): UnresolvedRef {
  return {
    fromNodeId: `caller:${filePath}`,
    referenceName: name,
    referenceKind: 'calls',
    line: 1,
    column: 0,
    filePath,
    language,
  };
}

describe('React Native bridge resolver', () => {
  describe('detect()', () => {
    it('returns true when package.json declares react-native', () => {
      const ctx = makeContext([], {
        'package.json':
          '{"name":"x","dependencies":{"react-native":"^0.73.0"}}',
      });
      expect(reactNativeBridgeResolver.detect(ctx)).toBe(true);
    });

    it('returns true when an ObjC file uses RCT_EXPORT_MODULE', () => {
      const ctx = makeContext([], {
        'NativeFoo.mm': '@implementation Foo\nRCT_EXPORT_MODULE()\n@end',
      });
      expect(reactNativeBridgeResolver.detect(ctx)).toBe(true);
    });

    it('returns true when a TS file uses TurboModuleRegistry', () => {
      const ctx = makeContext([], {
        'NativeFoo.ts':
          "import { TurboModuleRegistry } from 'react-native';\n" +
          "export default TurboModuleRegistry.getEnforcing<Spec>('Foo');",
      });
      expect(reactNativeBridgeResolver.detect(ctx)).toBe(true);
    });

    it('returns false when none of the RN signals are present', () => {
      const ctx = makeContext([method('hi', 'objc', 'X.m')]);
      expect(reactNativeBridgeResolver.detect(ctx)).toBe(false);
    });
  });

  describe('legacy bridge — ObjC side', () => {
    it('resolves JS callsite via RCT_EXPORT_METHOD with default module name', () => {
      // RCTGeolocation → module name 'Geolocation' (RCT prefix stripped).
      const native = method('getCurrentPosition:', 'objc', 'RCTGeolocation.m');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'RCTGeolocation.m':
          '@implementation RCTGeolocation\n' +
          'RCT_EXPORT_MODULE()\n' +
          'RCT_EXPORT_METHOD(getCurrentPosition:(RCTResponseSenderBlock)cb) {}\n' +
          '@end',
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('getCurrentPosition', 'javascript', 'App.js'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
      expect(result?.resolvedBy).toBe('framework');
    });

    it('resolves via explicit module name in RCT_EXPORT_MODULE(name)', () => {
      const native = method('startScan:', 'objc', 'Bluetooth.m');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'Bluetooth.m':
          '@implementation BluetoothImpl\n' +
          'RCT_EXPORT_MODULE(BluetoothManager)\n' +
          'RCT_EXPORT_METHOD(startScan:(RCTResponseSenderBlock)cb) {}\n' +
          '@end',
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('startScan', 'javascript', 'App.js'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
    });

    it('resolves RCT_REMAP_METHOD with JS-name override', () => {
      const native = method('doInternalCompute:', 'objc', 'Computer.m');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'Computer.m':
          '@implementation Computer\n' +
          'RCT_EXPORT_MODULE()\n' +
          'RCT_REMAP_METHOD(compute, doInternalCompute:(NSDictionary *)opts) {}\n' +
          '@end',
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('compute', 'javascript', 'App.js'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
    });
  });

  describe('legacy bridge — Java side', () => {
    it('resolves @ReactMethod with getName() literal', () => {
      const native = method('getCurrentPosition', 'java', 'GeolocationModule.java');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'GeolocationModule.java':
          'class GeolocationModule extends ReactContextBaseJavaModule {\n' +
          '  @Override public String getName() { return "Geolocation"; }\n' +
          '  @ReactMethod public void getCurrentPosition(Callback cb) {}\n' +
          '}',
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('getCurrentPosition', 'javascript', 'App.js'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
    });

    it('resolves Kotlin @ReactMethod fun', () => {
      const native = method('startScan', 'kotlin', 'BluetoothModule.kt');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'BluetoothModule.kt':
          'class BluetoothModule(ctx: ReactApplicationContext) : ReactContextBaseJavaModule(ctx) {\n' +
          '  override fun getName(): String = "BluetoothManager"\n' +
          '  @ReactMethod fun startScan(cb: Callback) {}\n' +
          '}',
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('startScan', 'javascript', 'App.js'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
    });
  });

  describe('TurboModule spec resolution', () => {
    it('matches spec method to native ObjC implementation by name', () => {
      // The Spec interface lists `getTotalLength`; ObjC has a method by the
      // same first keyword. Bridge matches by name.
      const native = method('getTotalLength:', 'objc', 'RNSVGRenderableManager.mm');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'NativeSvgRenderableModule.ts':
          "import { TurboModuleRegistry } from 'react-native';\n" +
          'export interface Spec extends TurboModule {\n' +
          '  getTotalLength(tag: number): number;\n' +
          '  isPointInFill(tag: number, options?: object): boolean;\n' +
          '}\n' +
          "export default TurboModuleRegistry.getEnforcing<Spec>('RNSVGRenderableModule');",
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('getTotalLength', 'tsx', 'SvgComponent.tsx'),
        ctx
      );
      expect(result?.targetNodeId).toBe(native.id);
    });

    it('returns null when spec method has no matching native impl', () => {
      const ctx = makeContext([], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'NativeFoo.ts':
          "import { TurboModuleRegistry } from 'react-native';\n" +
          'export interface Spec extends TurboModule {\n' +
          '  thingThatDoesntExist(): void;\n' +
          '}\n' +
          "export default TurboModuleRegistry.getEnforcing<Spec>('Foo');",
      });
      const result = reactNativeBridgeResolver.resolve(
        ref('thingThatDoesntExist', 'tsx', 'Caller.tsx'),
        ctx
      );
      expect(result).toBeNull();
    });
  });

  describe('qualified vs bare callsite names', () => {
    it('handles bare method name (post receiver-strip)', () => {
      const native = method('compute:', 'objc', 'Mod.m');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'Mod.m':
          '@implementation Mod\nRCT_EXPORT_MODULE()\nRCT_EXPORT_METHOD(compute:(NSDictionary *)x) {}\n@end',
      });
      expect(
        reactNativeBridgeResolver.resolve(ref('compute', 'javascript', 'App.js'), ctx)
      ).not.toBeNull();
    });

    it('strips dot prefix on receiver-qualified callsite (NativeModules.Mod.compute → compute)', () => {
      const native = method('compute:', 'objc', 'Mod.m');
      const ctx = makeContext([native], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'Mod.m':
          '@implementation Mod\nRCT_EXPORT_MODULE()\nRCT_EXPORT_METHOD(compute:(NSDictionary *)x) {}\n@end',
      });
      expect(
        reactNativeBridgeResolver.resolve(
          ref('NativeModules.Mod.compute', 'javascript', 'App.js'),
          ctx
        )
      ).not.toBeNull();
    });
  });

  it('does not resolve native-language callers (resolver is JS-side only)', () => {
    const native = method('compute:', 'objc', 'Mod.m');
    const ctx = makeContext([native]);
    expect(
      reactNativeBridgeResolver.resolve(ref('compute', 'objc', 'OtherMod.m'), ctx)
    ).toBeNull();
  });

  describe('RCTEventEmitter built-ins blocklist', () => {
    it('skips addListener / remove (every emitter exposes these — bridging them creates noise)', () => {
      // A repo with RCTEventEmitter subclass: defines `addListener:` and
      // `remove:` because that's what `[RCTEventEmitter addListener:]`
      // requires. JS callers of `.addListener(...)` should NOT resolve
      // here — they're hitting the JS-side `NativeEventEmitter`
      // abstraction, not the native emitter directly.
      const native1 = method('addListener:', 'objc', 'EventEmitter.m');
      const native2 = method('remove:', 'objc', 'EventEmitter.m');
      const ctx = makeContext([native1, native2], {
        'package.json': '{"dependencies":{"react-native":"^0.73"}}',
        'EventEmitter.m':
          '@implementation EventEmitter\n' +
          'RCT_EXPORT_MODULE()\n' +
          'RCT_EXPORT_METHOD(addListener:(NSString *)eventName) {}\n' +
          'RCT_EXPORT_METHOD(remove:(double)id) {}\n' +
          '@end',
      });
      expect(
        reactNativeBridgeResolver.resolve(ref('addListener', 'javascript', 'App.js'), ctx)
      ).toBeNull();
      expect(
        reactNativeBridgeResolver.resolve(ref('remove', 'typescript', 'App.ts'), ctx)
      ).toBeNull();
    });
  });
});

describe('React Native cross-platform pairing — end to end', () => {
  let dir: string;
  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rn-xplat-')); });
  afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });

  it('links the Android (@ReactMethod) and iOS (RCT_EXPORT_METHOD) impls of a JS-called method', async () => {
    fs.writeFileSync(path.join(dir, 'package.json'), '{"dependencies":{"react-native":"^0.74.0"}}');
    fs.writeFileSync(path.join(dir, 'index.ts'),
      "import { NativeModules } from 'react-native';\n" +
      "export function ping() { return NativeModules.RNThing.uniquePingMethod(); }\n");
    fs.writeFileSync(path.join(dir, 'RNThing.java'),
      "public class RNThing extends ReactContextBaseJavaModule {\n" +
      "  @Override public String getName() { return \"RNThing\"; }\n" +
      "  @ReactMethod public void uniquePingMethod(Callback cb) {}\n}\n");
    fs.writeFileSync(path.join(dir, 'RNThing.m'),
      "@implementation RNThing\n" +
      "RCT_EXPORT_MODULE()\n" +
      "RCT_EXPORT_METHOD(uniquePingMethod:(RCTResponseSenderBlock)cb) {}\n@end\n");

    const cg = await CodeGraph.init(dir, { silent: true });
    await cg.indexAll();
    const db = (cg as any).db.db;

    // The iOS `RCT_EXPORT_METHOD` is extracted as an ObjC method node (the macro
    // parses as a macro-expression, not a method, so it had no node before).
    const objc = db.prepare(
      "SELECT * FROM nodes WHERE name='uniquePingMethod' AND language='objc' AND id LIKE 'rn-export:%'"
    ).all();
    expect(objc).toHaveLength(1);

    // The Java and ObjC impls of `uniquePingMethod` are linked to each other, so
    // a JS call that resolves to one platform reaches the other.
    const pair = db.prepare(
      `SELECT count(*) c FROM edges e
       JOIN nodes s ON s.id=e.source JOIN nodes t ON t.id=e.target
       WHERE json_extract(e.metadata,'$.synthesizedBy')='rn-cross-platform'
         AND s.name LIKE 'uniquePingMethod%' AND t.name LIKE 'uniquePingMethod%'
         AND s.language != t.language`
    ).get();
    cg.close?.();
    expect(pair.c).toBeGreaterThanOrEqual(2); // java<->objc both directions
  });
});
