import { describe, expect, test } from 'vitest'
import { isActorExcluded, actorTypeMap } from '../scripts/sync'

describe('excluded_actors filtering', () => {
  test('returns false when excludedActors is undefined', () => {
    expect(isActorExcluded(undefined, 'server_to_server')).toBe(false)
  })

  test('returns false when excludedActors is null', () => {
    expect(isActorExcluded(null, 'server_to_server')).toBe(false)
  })

  test('returns false when excludedActors is not an array', () => {
    expect(isActorExcluded('not-an-array', 'server_to_server')).toBe(false)
    expect(isActorExcluded({}, 'server_to_server')).toBe(false)
  })

  test('returns false when excludedActors is empty array', () => {
    expect(isActorExcluded([], 'server_to_server')).toBe(false)
  })

  test('returns true when actorType is in excludedActors', () => {
    expect(isActorExcluded(['server_to_server'], 'server_to_server')).toBe(true)
    expect(isActorExcluded(['server_to_server', 'fine_grained_pat'], 'server_to_server')).toBe(true)
    expect(isActorExcluded(['user_to_server', 'fine_grained_pat'], 'fine_grained_pat')).toBe(true)
  })

  test('returns false when actorType is not in excludedActors', () => {
    expect(isActorExcluded(['server_to_server'], 'fine_grained_pat')).toBe(false)
    expect(isActorExcluded(['user_to_server'], 'server_to_server')).toBe(false)
    expect(isActorExcluded(['server_to_server', 'user_to_server'], 'fine_grained_pat')).toBe(false)
  })

  test('handles various actor type values', () => {
    const excludedActors = ['server_to_server', 'fine_grained_pat', 'user_to_server']

    expect(isActorExcluded(excludedActors, 'server_to_server')).toBe(true)
    expect(isActorExcluded(excludedActors, 'fine_grained_pat')).toBe(true)
    expect(isActorExcluded(excludedActors, 'user_to_server')).toBe(true)
    expect(isActorExcluded(excludedActors, 'some_other_actor')).toBe(false)
  })

  test('handles actor type mapping from generic to YAML values', () => {
    // Test with actual YAML values that would come from the config files
    expect(isActorExcluded(['UserProgrammaticAccess'], 'fine_grained_pat', actorTypeMap)).toBe(true)
    expect(isActorExcluded(['github_app'], 'server_to_server', actorTypeMap)).toBe(true)
    expect(isActorExcluded(['user_access_token'], 'user_to_server', actorTypeMap)).toBe(true)

    // Test fallback when no mapping exists
    expect(isActorExcluded(['some_unmapped_actor'], 'some_unmapped_actor')).toBe(true)
    expect(isActorExcluded(['some_unmapped_actor'], 'different_actor')).toBe(false)
  })

  test('handles mixed generic and YAML actor type values', () => {
    const mixedExcludedActors = ['UserProgrammaticAccess', 'github_app', 'user_access_token']

    // Should match mapped values
    expect(isActorExcluded(mixedExcludedActors, 'fine_grained_pat', actorTypeMap)).toBe(true)
    expect(isActorExcluded(mixedExcludedActors, 'server_to_server', actorTypeMap)).toBe(true)
    expect(isActorExcluded(mixedExcludedActors, 'user_to_server', actorTypeMap)).toBe(true)

    // Should not match unmapped values
    expect(isActorExcluded(mixedExcludedActors, 'unmapped_actor', actorTypeMap)).toBe(false)
  })

  test('verifies independent filtering of server_to_server and user_to_server', () => {
    // Only server_to_server excluded
    const onlyServerExcluded = ['server_to_server']
    expect(isActorExcluded(onlyServerExcluded, 'server_to_server')).toBe(true)
    expect(isActorExcluded(onlyServerExcluded, 'user_to_server')).toBe(false)

    // Only user_to_server excluded
    const onlyUserExcluded = ['user_to_server']
    expect(isActorExcluded(onlyUserExcluded, 'server_to_server')).toBe(false)
    expect(isActorExcluded(onlyUserExcluded, 'user_to_server')).toBe(true)

    // Both excluded
    const bothExcluded = ['server_to_server', 'user_to_server']
    expect(isActorExcluded(bothExcluded, 'server_to_server')).toBe(true)
    expect(isActorExcluded(bothExcluded, 'user_to_server')).toBe(true)

    // Neither excluded
    const neitherExcluded = ['fine_grained_pat']
    expect(isActorExcluded(neitherExcluded, 'server_to_server')).toBe(false)
    expect(isActorExcluded(neitherExcluded, 'user_to_server')).toBe(false)
  })

  test('handles actor type mapping from generic to YAML values', () => {
    // Test with actual YAML values that would come from the config files
    expect(
      isActorExcluded(['fine_grained_personal_access_token'], 'fine_grained_pat', actorTypeMap),
    ).toBe(true)
    expect(isActorExcluded(['github_app'], 'server_to_server', actorTypeMap)).toBe(true)
    expect(isActorExcluded(['user_access_token'], 'user_to_server', actorTypeMap)).toBe(true)

    // Test fallback when no mapping exists
    expect(isActorExcluded(['some_unmapped_actor'], 'some_unmapped_actor')).toBe(true)
    expect(isActorExcluded(['some_unmapped_actor'], 'different_actor')).toBe(false)
  })

  test('handles mixed generic and YAML actor type values', () => {
    const mixedExcludedActors = [
      'fine_grained_personal_access_token',
      'github_app',
      'user_access_token',
    ]

    // Should match mapped values
    expect(isActorExcluded(mixedExcludedActors, 'fine_grained_pat', actorTypeMap)).toBe(true)
    expect(isActorExcluded(mixedExcludedActors, 'server_to_server', actorTypeMap)).toBe(true)

    // Should match mapped values
    expect(isActorExcluded(mixedExcludedActors, 'user_to_server', actorTypeMap)).toBe(true)

    // Should not match unmapped values
    expect(isActorExcluded(mixedExcludedActors, 'unmapped_actor', actorTypeMap)).toBe(false)
  })

  test('handles UserProgrammaticAccess alias for fine_grained_pat', () => {
    // Test that UserProgrammaticAccess (actual source data value) is recognized as fine_grained_pat
    expect(isActorExcluded(['UserProgrammaticAccess'], 'fine_grained_pat')).toBe(true)

    // Test mixed scenarios with UserProgrammaticAccess
    const mixedWithUserProgrammatic = ['UserProgrammaticAccess', 'github_app']
    expect(isActorExcluded(mixedWithUserProgrammatic, 'fine_grained_pat')).toBe(true)
    expect(isActorExcluded(mixedWithUserProgrammatic, 'server_to_server', actorTypeMap)).toBe(true)
    expect(isActorExcluded(mixedWithUserProgrammatic, 'user_to_server')).toBe(false)

    // Test that both mapped value and alias work
    const bothValues = ['fine_grained_personal_access_token', 'UserProgrammaticAccess']
    expect(isActorExcluded(bothValues, 'fine_grained_pat', actorTypeMap)).toBe(true)
  })
})