import { describe, it, expect } from 'vitest'
import type { VaultEntry } from '../types'
import {
  wikilinkTarget,
  wikilinkDisplay,
  resolveEntry,
  relativePathStem,
  slugifyWikilinkTarget,
  canonicalWikilinkTargetForEntry,
  canonicalWikilinkTargetForTitle,
  formatWikilinkRef,
} from './wikilink'

function makeEntry(overrides: Partial<VaultEntry>): VaultEntry {
  return {
    path: '/vault/note.md', filename: 'note.md', title: 'Note', isA: null,
    aliases: [], belongsTo: [], relatedTo: [], status: null, archived: false,
    modifiedAt: null, createdAt: null, fileSize: 100, snippet: '', wordCount: 0,
    relationships: {}, icon: null, color: null, order: null, template: null,
    sort: null, outgoingLinks: [], sidebarLabel: null, view: null, visible: null,
    properties: {},
    ...overrides,
  }
}

describe('wikilinkTarget', () => {
  it('strips brackets', () => {
    expect(wikilinkTarget('[[foo]]')).toBe('foo')
  })
  it('returns target before pipe', () => {
    expect(wikilinkTarget('[[path|display]]')).toBe('path')
  })
  it('handles bare text without brackets', () => {
    expect(wikilinkTarget('just text')).toBe('just text')
  })
})

describe('wikilinkDisplay', () => {
  it('returns text after pipe', () => {
    expect(wikilinkDisplay('[[path|My Title]]')).toBe('My Title')
  })
  it('humanises slug when no pipe', () => {
    expect(wikilinkDisplay('[[my-note]]')).toBe('My Note')
  })
})

describe('resolveEntry', () => {
  const alice = makeEntry({ path: '/vault/person/alice.md', filename: 'alice.md', title: 'Alice', isA: 'Person', aliases: ['Alice Smith'] })
  const bob = makeEntry({ path: '/vault/person/bob.md', filename: 'bob.md', title: 'Bob', isA: 'Person' })
  const project = makeEntry({ path: '/vault/project/my-project.md', filename: 'my-project.md', title: 'My Project', isA: 'Project' })
  const entries = [alice, bob, project]

  it('matches by title (case-insensitive)', () => {
    expect(resolveEntry(entries, 'alice')).toBe(alice)
    expect(resolveEntry(entries, 'ALICE')).toBe(alice)
    expect(resolveEntry(entries, 'Alice')).toBe(alice)
  })

  it('matches by alias (case-insensitive)', () => {
    expect(resolveEntry(entries, 'alice smith')).toBe(alice)
    expect(resolveEntry(entries, 'Alice Smith')).toBe(alice)
  })

  it('matches by filename stem (case-insensitive)', () => {
    expect(resolveEntry(entries, 'my-project')).toBe(project)
    expect(resolveEntry(entries, 'My-Project')).toBe(project)
  })

  it('matches legacy path-style targets via last segment', () => {
    expect(resolveEntry(entries, 'person/alice')).toBe(alice)
    expect(resolveEntry(entries, 'project/my-project')).toBe(project)
  })

  it('handles pipe syntax: uses target part for lookup', () => {
    expect(resolveEntry(entries, 'person/alice|Alice S.')).toBe(alice)
    expect(resolveEntry(entries, 'Alice|A')).toBe(alice)
  })

  it('returns undefined for non-existent target', () => {
    expect(resolveEntry(entries, 'Does Not Exist')).toBeUndefined()
  })

  it('returns undefined for empty entries', () => {
    expect(resolveEntry([], 'Alice')).toBeUndefined()
  })

  it('matches by filename stem from last segment of path target', () => {
    // If target is "person/alice", the last segment "alice" should match filename stem
    expect(resolveEntry(entries, 'person/alice')).toBe(alice)
  })

  it('matches title-as-words from kebab-case target', () => {
    // "my-project" → "my project" should match title "My Project"
    expect(resolveEntry(entries, 'my-project')).toBe(project)
  })

  it('prefers filename stem over title when ambiguous', () => {
    // Entry has filename "foo.md" but title "Bar"
    const fooEntry = makeEntry({ path: '/vault/foo.md', filename: 'foo.md', title: 'Bar' })
    // Entry has filename "bar.md" but title "Foo"
    const barEntry = makeEntry({ path: '/vault/bar.md', filename: 'bar.md', title: 'Foo' })
    const ambiguous = [fooEntry, barEntry]
    // Searching for "foo" should match fooEntry (by filename stem) not barEntry (by title)
    expect(resolveEntry(ambiguous, 'foo')).toBe(fooEntry)
    // Searching for "bar" should match barEntry (by filename stem) not fooEntry (by title)
    expect(resolveEntry(ambiguous, 'bar')).toBe(barEntry)
  })

  it('resolves path-style target by matching path suffix', () => {
    const adr = makeEntry({ path: '/vault/docs/adr/0031-foo.md', filename: '0031-foo.md', title: '0031 Foo' })
    const flat = makeEntry({ path: '/vault/hello.md', filename: 'hello.md', title: 'Hello' })
    expect(resolveEntry([adr, flat], 'docs/adr/0031-foo')).toBe(adr)
  })

  it('disambiguates same-name files in different subfolders via path', () => {
    const alpha = makeEntry({ path: '/vault/projects/alpha.md', filename: 'alpha.md', title: 'Alpha' })
    const alphaArchived = makeEntry({ path: '/vault/archive/alpha.md', filename: 'alpha.md', title: 'Alpha' })
    expect(resolveEntry([alpha, alphaArchived], 'projects/alpha')).toBe(alpha)
    expect(resolveEntry([alpha, alphaArchived], 'archive/alpha')).toBe(alphaArchived)
  })

  it('resolves full-path wikilinks to non-Markdown duplicate filenames', () => {
    const yamlA = makeEntry({ path: '/vault/a/file.yml', filename: 'file.yml', title: 'file.yml', fileKind: 'text' })
    const yamlB = makeEntry({ path: '/vault/b/file.yml', filename: 'file.yml', title: 'file.yml', fileKind: 'text' })
    const pdfA = makeEntry({ path: '/vault/a/document.pdf', filename: 'document.pdf', title: 'document.pdf', fileKind: 'binary' })
    const pdfB = makeEntry({ path: '/vault/b/document.pdf', filename: 'document.pdf', title: 'document.pdf', fileKind: 'binary' })
    const targetA = makeEntry({ path: '/vault/a/target.md', filename: 'target.md', title: 'Target' })
    const targetB = makeEntry({ path: '/vault/b/target.md', filename: 'target.md', title: 'Target' })
    const duplicateEntries = [yamlA, yamlB, pdfA, pdfB, targetA, targetB]

    expect(resolveEntry(duplicateEntries, 'b/file.yml')).toBe(yamlB)
    expect(resolveEntry(duplicateEntries, 'b/document.pdf')).toBe(pdfB)
    expect(resolveEntry(duplicateEntries, 'b/target.md')).toBe(targetB)
  })

  it('resolves workspace-prefixed targets inside the matching mounted workspace', () => {
    const personal = makeEntry({
      path: '/personal/projects/alpha.md',
      filename: 'alpha.md',
      title: 'Alpha',
      workspace: { id: 'personal', label: 'Personal', alias: 'personal', path: '/personal', shortLabel: 'PE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: true },
    })
    const team = makeEntry({
      path: '/team/projects/alpha.md',
      filename: 'alpha.md',
      title: 'Alpha',
      workspace: { id: 'team', label: 'Team', alias: 'team', path: '/team', shortLabel: 'TE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: false },
    })

    expect(resolveEntry([personal, team], 'team/projects/alpha', personal)).toBe(team)
  })

  it('prefers local workspace targets when links are unprefixed', () => {
    const personal = makeEntry({
      path: '/personal/alpha.md',
      filename: 'alpha.md',
      title: 'Alpha',
      workspace: { id: 'personal', label: 'Personal', alias: 'personal', path: '/personal', shortLabel: 'PE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: true },
    })
    const team = makeEntry({
      path: '/team/alpha.md',
      filename: 'alpha.md',
      title: 'Alpha',
      workspace: { id: 'team', label: 'Team', alias: 'team', path: '/team', shortLabel: 'TE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: false },
    })

    expect(resolveEntry([team, personal], 'alpha', personal)).toBe(personal)
  })
})

describe('relativePathStem', () => {
  it('extracts relative path stem from absolute path and vault path', () => {
    expect(relativePathStem('/Users/luca/Vault/note.md', '/Users/luca/Vault')).toBe('note')
  })

  it('preserves subdirectory structure', () => {
    expect(relativePathStem('/Users/luca/Vault/docs/adr/0031.md', '/Users/luca/Vault')).toBe('docs/adr/0031')
  })

  it('normalizes Windows extended-length paths before extracting the vault-relative stem', () => {
    expect(
      relativePathStem(
        '\\\\?\\C:\\Users\\lrfno\\Documents\\tolaria-vault\\application-design-and-build.md',
        'C:\\Users\\lrfno\\Documents\\tolaria-vault',
      ),
    ).toBe('application-design-and-build')
  })

  it('keeps nested Windows note paths vault-relative with slash separators', () => {
    expect(
      relativePathStem(
        'C:\\Users\\lrfno\\Documents\\Tolaria Vault\\projects\\application-design-and-build.md',
        'c:/users/lrfno/documents/tolaria vault',
      ),
    ).toBe('projects/application-design-and-build')
  })

  it('falls back to filename stem when vault path does not match', () => {
    expect(relativePathStem('/other/path/note.md', '/Users/luca/Vault')).toBe('note')
  })
})

describe('slugifyWikilinkTarget', () => {
  it('slugifies a human title to a canonical target', () => {
    expect(slugifyWikilinkTarget('Weekly Review')).toBe('weekly-review')
  })

  it('preserves Unicode titles when no existing entry resolves them', () => {
    expect(slugifyWikilinkTarget('你好')).toBe('你好')
  })

  it('falls back to untitled when the title has no slug characters', () => {
    expect(slugifyWikilinkTarget('+++')).toBe('untitled')
  })
})

describe('canonicalWikilinkTargetForEntry', () => {
  it('returns a vault-relative path stem', () => {
    const entry = makeEntry({ path: '/vault/projects/alpha.md', filename: 'alpha.md', title: 'Alpha' })
    expect(canonicalWikilinkTargetForEntry(entry, '/vault')).toBe('projects/alpha')
  })

  it('prefixes cross-workspace targets with the stable alias', () => {
    const source = makeEntry({
      path: '/personal/source.md',
      filename: 'source.md',
      title: 'Source',
      workspace: { id: 'personal', label: 'Personal', alias: 'personal', path: '/personal', shortLabel: 'PE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: true },
    })
    const target = makeEntry({
      path: '/team/projects/alpha.md',
      filename: 'alpha.md',
      title: 'Alpha',
      workspace: { id: 'team', label: 'Team', alias: 'team', path: '/team', shortLabel: 'TE', color: null, icon: null, mounted: true, available: true, defaultForNewNotes: false },
    })

    expect(canonicalWikilinkTargetForEntry(target, '/personal', source)).toBe('team/projects/alpha')
  })
})

describe('canonicalWikilinkTargetForTitle', () => {
  const project = makeEntry({ path: '/vault/projects/alpha.md', filename: 'alpha.md', title: 'Alpha Project' })

  it('resolves an existing entry to its canonical path target', () => {
    expect(canonicalWikilinkTargetForTitle('Alpha Project', [project], '/vault')).toBe('projects/alpha')
  })

  it('keeps a canonical path input canonical', () => {
    expect(canonicalWikilinkTargetForTitle('projects/alpha', [project], '/vault')).toBe('projects/alpha')
  })

  it('falls back to a slug for a newly created note title', () => {
    expect(canonicalWikilinkTargetForTitle('Brand New Note', [], '/vault')).toBe('brand-new-note')
  })

  it('falls back to a Unicode-preserving slug for a newly created note title', () => {
    expect(canonicalWikilinkTargetForTitle('你好', [], '/vault')).toBe('你好')
  })
})

describe('formatWikilinkRef', () => {
  it('wraps a canonical target in wikilink syntax', () => {
    expect(formatWikilinkRef('projects/alpha')).toBe('[[projects/alpha]]')
  })
})