import {
  convertSilkeCommandsToString,
  escapeHtml,
  filterAndSortCommands,
  getActiveCommandIndex,
  getCommandMatchScore,
  getItemLength,
  getTextLength,
  isAttachment,
  isFile,
  isImage,
  isSilkeCommand,
  isText,
  SilkeCommand,
  SilkeCommandTextFieldValue,
  SilkeCommandType,
  SilkeFileValue,
  SilkeImageValue,
  valueToHtml,
} from './utils';

describe('escapeHtml', () => {
  test('escapes HTML special characters', () => {
    expect(escapeHtml('<script>alert("xss")</script>')).toBe(
      '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;',
    );
  });

  test('escapes ampersand', () => {
    expect(escapeHtml('foo & bar')).toBe('foo &amp; bar');
  });

  test('escapes single quotes', () => {
    expect(escapeHtml("it's")).toBe('it&#39;s');
  });

  test('returns empty string for empty input', () => {
    expect(escapeHtml('')).toBe('');
  });

  test('returns text unchanged if no special characters', () => {
    expect(escapeHtml('Hello world 123')).toBe('Hello world 123');
  });
});

describe('getActiveCommandIndex', () => {
  const testValue: SilkeCommandTextFieldValue[] = [
    { type: 'text', value: 'Hello ' },
    { type: SilkeCommandType.MENTION, value: 'user' },
    { type: 'text', value: ' world' },
  ];

  test('returns 0 for empty array', () => {
    expect(getActiveCommandIndex(0, [])).toBe(0);
  });

  test('returns 0 for caret at start', () => {
    expect(getActiveCommandIndex(0, testValue)).toBe(0);
  });

  test('returns correct index for caret in text segment', () => {
    expect(getActiveCommandIndex(3, testValue)).toBe(0);
  });

  test('returns command index when caret at boundary (start of command)', () => {
    // Position 6 is at '@', the first char of the command
    expect(getActiveCommandIndex(6, testValue)).toBe(1);
  });

  test('returns correct index for caret at command', () => {
    // "Hello " = 6 chars, "@user" = 5 chars (@ + user), caret at 8 is inside @user
    expect(getActiveCommandIndex(8, testValue)).toBe(1);
  });

  test('returns correct index for caret after command', () => {
    // "Hello " (6) + "@user" (5) + " " (1) = 12, caret at 13 is in " world"
    expect(getActiveCommandIndex(13, testValue)).toBe(2);
  });

  test('returns last index for caret at end', () => {
    // Total: "Hello " (6) + "@user" (5) + " world" (6) = 17
    expect(getActiveCommandIndex(17, testValue)).toBe(2);
  });

  test('handles undefined value array', () => {
    expect(getActiveCommandIndex(0, undefined as unknown as SilkeCommandTextFieldValue[])).toBe(0);
  });
});

describe('getTextLength', () => {
  const testValue: SilkeCommandTextFieldValue[] = [
    { type: 'text', value: 'Hello ' },
    { type: SilkeCommandType.MENTION, value: 'user' },
    { type: 'text', value: ' world' },
  ];

  test('returns 0 for empty array', () => {
    expect(getTextLength([])).toBe(0);
  });

  test('returns 0 for index 0', () => {
    expect(getTextLength(testValue, 0)).toBe(0);
  });

  test('returns correct length for text segment', () => {
    expect(getTextLength(testValue, 1)).toBe(6); // "Hello "
  });

  test('returns correct length including command (with @ symbol)', () => {
    expect(getTextLength(testValue, 2)).toBe(11); // "Hello " + "@user"
  });

  test('returns total length for full array', () => {
    expect(getTextLength(testValue)).toBe(17); // "Hello " + "@user" + " world"
  });

  test('handles negative index', () => {
    expect(getTextLength(testValue, -1)).toBe(0);
  });

  test('handles undefined value array', () => {
    expect(getTextLength(undefined as unknown as SilkeCommandTextFieldValue[])).toBe(0);
  });
});

describe('getItemLength', () => {
  test('returns correct length for text', () => {
    expect(getItemLength({ type: 'text', value: 'hello' })).toBe(5);
  });

  test('returns correct length for command (value + 1 for symbol)', () => {
    expect(getItemLength({ type: SilkeCommandType.MENTION, value: 'user' })).toBe(5);
  });

  test('returns 0 for undefined', () => {
    expect(getItemLength(undefined as unknown as SilkeCommandTextFieldValue)).toBe(0);
  });
});

describe('valueToHtml', () => {
  const mockStyles = {
    action: 'action-class',
    mention: 'mention-class',
    partial: 'partial-class',
    tag: 'tag-class',
  };

  test('returns empty string for empty array', () => {
    expect(valueToHtml([], mockStyles)).toBe('');
  });

  test('wraps text in span', () => {
    const value: SilkeCommandTextFieldValue[] = [{ type: 'text', value: 'hello' }];
    expect(valueToHtml(value, mockStyles)).toBe('<span>hello</span>');
  });

  test('renders mention command with correct classes', () => {
    const value: SilkeCommandTextFieldValue[] = [{ type: SilkeCommandType.MENTION, value: 'user' }];
    const html = valueToHtml(value, mockStyles);
    expect(html).toContain('tag-class');
    expect(html).toContain('mention-class');
    expect(html).toContain('@user');
  });

  test('renders action command with correct classes', () => {
    const value: SilkeCommandTextFieldValue[] = [{ type: SilkeCommandType.ACTION, value: 'cmd' }];
    const html = valueToHtml(value, mockStyles);
    expect(html).toContain('tag-class');
    expect(html).toContain('action-class');
    expect(html).toContain('/cmd');
  });

  test('adds partial class for partial commands', () => {
    const value: SilkeCommandTextFieldValue[] = [
      { partialMatch: true, type: SilkeCommandType.MENTION, value: 'unknown' },
    ];
    const html = valueToHtml(value, mockStyles);
    expect(html).toContain('partial-class');
  });

  test('escapes HTML in text values', () => {
    const value: SilkeCommandTextFieldValue[] = [
      { type: 'text', value: '<script>alert("xss")</script>' },
    ];
    const html = valueToHtml(value, mockStyles);
    expect(html).not.toContain('<script>');
    expect(html).toContain('&lt;script&gt;');
  });

  test('escapes HTML in command values', () => {
    const value: SilkeCommandTextFieldValue[] = [
      { partialMatch: true, type: SilkeCommandType.MENTION, value: '<img onerror=alert(1)>' },
    ];
    const html = valueToHtml(value, mockStyles);
    expect(html).not.toContain('<img');
    expect(html).toContain('&lt;img');
  });

  test('handles undefined value array', () => {
    expect(valueToHtml(undefined as unknown as SilkeCommandTextFieldValue[], mockStyles)).toBe('');
  });
});

describe('valueToString', () => {
  test('returns empty string for empty array', () => {
    expect(convertSilkeCommandsToString([])).toBe('');
  });

  test('converts text segments correctly', () => {
    const value: SilkeCommandTextFieldValue[] = [{ type: 'text', value: 'hello world' }];
    expect(convertSilkeCommandsToString(value)).toBe('hello world');
  });

  test('converts commands with their symbol', () => {
    const value: SilkeCommandTextFieldValue[] = [{ type: SilkeCommandType.MENTION, value: 'user' }];
    expect(convertSilkeCommandsToString(value)).toBe('@user');
  });

  test('converts mixed content correctly', () => {
    const value: SilkeCommandTextFieldValue[] = [
      { type: 'text', value: 'Hello ' },
      { type: SilkeCommandType.MENTION, value: 'user' },
      { type: 'text', value: ' please /run' },
    ];
    expect(convertSilkeCommandsToString(value)).toBe('Hello @user please /run');
  });

  test('handles undefined value array', () => {
    expect(convertSilkeCommandsToString(undefined as unknown as SilkeCommandTextFieldValue[])).toBe(
      '',
    );
  });
});

describe('isCommand', () => {
  test('returns true for mention command', () => {
    expect(isSilkeCommand({ type: SilkeCommandType.MENTION, value: 'user' })).toBe(true);
  });

  test('returns true for action command', () => {
    expect(isSilkeCommand({ type: SilkeCommandType.ACTION, value: 'cmd' })).toBe(true);
  });

  test('returns false for text', () => {
    expect(isSilkeCommand({ type: 'text', value: 'hello' })).toBe(false);
  });

  test('returns false for undefined', () => {
    expect(isSilkeCommand(undefined)).toBe(false);
  });

  test('returns false for null', () => {
    expect(isSilkeCommand(null as unknown as SilkeCommandTextFieldValue)).toBe(false);
  });
});

describe('isText', () => {
  test('returns true for text', () => {
    expect(isText({ type: 'text', value: 'hello' })).toBe(true);
  });

  test('returns false for mention command', () => {
    expect(isText({ type: SilkeCommandType.MENTION, value: 'user' })).toBe(false);
  });

  test('returns false for action command', () => {
    expect(isText({ type: SilkeCommandType.ACTION, value: 'cmd' })).toBe(false);
  });

  test('returns false for undefined', () => {
    expect(isText(undefined)).toBe(false);
  });

  test('returns false for null', () => {
    expect(isText(null as unknown as SilkeCommandTextFieldValue)).toBe(false);
  });
});

describe('getCommandMatchScore', () => {
  const createCommand = (value: string): SilkeCommand => ({
    type: SilkeCommandType.MENTION,
    value,
  });

  test('returns -1 for empty query', () => {
    expect(getCommandMatchScore(createCommand('user'), '')).toBe(-1);
  });

  test('returns highest score for exact match', () => {
    expect(getCommandMatchScore(createCommand('user'), 'user')).toBe(100);
  });

  test('returns high score for startsWith match', () => {
    const score = getCommandMatchScore(createCommand('username'), 'user');
    expect(score).toBeGreaterThan(80);
    expect(score).toBeLessThan(100);
  });

  test('returns medium-high score for word boundary match', () => {
    const score = getCommandMatchScore(createCommand('my-user'), 'user');
    expect(score).toBeGreaterThan(60);
    expect(score).toBeLessThan(80);
  });

  test('returns medium score for contains match', () => {
    const score = getCommandMatchScore(createCommand('superuser'), 'user');
    expect(score).toBeGreaterThan(40);
    expect(score).toBeLessThan(60);
  });

  test('returns low score for fuzzy match', () => {
    const score = getCommandMatchScore(createCommand('user'), 'ur');
    expect(score).toBeGreaterThanOrEqual(20);
    expect(score).toBeLessThan(40);
  });

  test('returns -1 for no match', () => {
    expect(getCommandMatchScore(createCommand('user'), 'xyz')).toBe(-1);
  });

  test('is case insensitive', () => {
    expect(getCommandMatchScore(createCommand('User'), 'user')).toBe(100);
    expect(getCommandMatchScore(createCommand('user'), 'USER')).toBe(100);
  });
});

describe('filterAndSortCommands', () => {
  const commands: SilkeCommand[] = [
    { type: SilkeCommandType.MENTION, value: 'alice' },
    { type: SilkeCommandType.MENTION, value: 'bob' },
    { type: SilkeCommandType.MENTION, value: 'alice-smith' },
    { type: SilkeCommandType.MENTION, value: 'charlie' },
    { type: SilkeCommandType.ACTION, value: 'run' },
  ];

  test('returns all commands of type sorted alphabetically for empty query', () => {
    const results = filterAndSortCommands(commands, '', SilkeCommandType.MENTION);
    expect(results).toHaveLength(4);
    expect(results[0].value).toBe('alice');
    expect(results[1].value).toBe('alice-smith');
    expect(results[2].value).toBe('bob');
    expect(results[3].value).toBe('charlie');
  });

  test('filters by command type', () => {
    const results = filterAndSortCommands(commands, 'r', SilkeCommandType.ACTION);
    expect(results).toHaveLength(1);
    expect(results[0].value).toBe('run');
  });

  test('sorts exact matches first', () => {
    const results = filterAndSortCommands(commands, 'alice', SilkeCommandType.MENTION);
    expect(results[0].value).toBe('alice');
  });

  test('sorts startsWith before contains', () => {
    const results = filterAndSortCommands(commands, 'ali', SilkeCommandType.MENTION);
    expect(results[0].value).toBe('alice');
    expect(results[1].value).toBe('alice-smith');
  });

  test('returns partial matches', () => {
    const results = filterAndSortCommands(commands, 'ice', SilkeCommandType.MENTION);
    expect(results.length).toBeGreaterThan(0);
    expect(results.some((r) => r.value === 'alice')).toBe(true);
  });

  test('returns empty array when no matches', () => {
    expect(filterAndSortCommands(commands, 'xyz', SilkeCommandType.MENTION)).toEqual([]);
  });
});

const fileValue: SilkeFileValue = {
  type: 'file',
  data: 'dGVzdA==',
  mimeType: 'text/csv',
  name: 'data.csv',
};

const imageValue: SilkeImageValue = {
  type: 'image',
  data: 'iVBORw0K',
  mimeType: 'image/png',
  name: 'photo.png',
};

describe('isFile', () => {
  test('returns true for file value', () => {
    expect(isFile(fileValue)).toBe(true);
  });

  test('returns false for image value', () => {
    expect(isFile(imageValue)).toBe(false);
  });

  test('returns false for text value', () => {
    expect(isFile({ type: 'text', value: 'hello' })).toBe(false);
  });

  test('returns false for command value', () => {
    expect(isFile({ type: SilkeCommandType.MENTION, value: 'user' })).toBe(false);
  });

  test('returns false for undefined', () => {
    expect(isFile(undefined)).toBe(false);
  });
});

describe('isImage', () => {
  test('returns true for image value', () => {
    expect(isImage(imageValue)).toBe(true);
  });

  test('returns false for file value', () => {
    expect(isImage(fileValue)).toBe(false);
  });
});

describe('isAttachment', () => {
  test('returns true for image value', () => {
    expect(isAttachment(imageValue)).toBe(true);
  });

  test('returns true for file value', () => {
    expect(isAttachment(fileValue)).toBe(true);
  });

  test('returns false for text value', () => {
    expect(isAttachment({ type: 'text', value: 'hello' })).toBe(false);
  });

  test('returns false for command value', () => {
    expect(isAttachment({ type: SilkeCommandType.MENTION, value: 'user' })).toBe(false);
  });

  test('returns false for undefined', () => {
    expect(isAttachment(undefined)).toBe(false);
  });
});

describe('functions skip file items', () => {
  const valueWithFile: SilkeCommandTextFieldValue[] = [
    { type: 'text', value: 'Hello' },
    fileValue,
    { type: 'text', value: ' world' },
  ];

  test('getTextLength ignores file items', () => {
    expect(getTextLength(valueWithFile)).toBe(11); // "Hello" + " world"
  });

  test('getItemLength returns 0 for file items', () => {
    expect(getItemLength(fileValue)).toBe(0);
  });

  test('getActiveCommandIndex skips file items', () => {
    // Caret at position 7 should be in " world" (index 2), not in file (index 1)
    expect(getActiveCommandIndex(7, valueWithFile)).toBe(2);
  });

  test('isSilkeCommand returns false for file items', () => {
    expect(isSilkeCommand(fileValue)).toBe(false);
  });

  test('convertSilkeCommandsToString ignores file items', () => {
    expect(convertSilkeCommandsToString(valueWithFile)).toBe('Hello world');
  });

  test('valueToHtml ignores file items', () => {
    const mockStyles = { action: 'a', mention: 'm', partial: 'p', tag: 't' };
    const html = valueToHtml(valueWithFile, mockStyles);
    expect(html).toBe('<span>Hello</span><span> world</span>');
  });
});