import { chosungIncludes } from './chosungIncludes';

describe('chosungIncludes', () => {
  it('should return true when "ㅍㄹㅌ" is entered for searching "프론트엔드"', () => {
    expect(chosungIncludes('프론트엔드', 'ㅍㄹㅌ')).toBe(true);
  });

  it('should return true when "ㅍㄹㅌ" is entered for searching "00프론트엔드"', () => {
    expect(chosungIncludes('00프론트엔드', 'ㅍㄹㅌ')).toBe(true);
  });

  it('should return false when "ㅍㅌ" is entered for searching "프론트엔드"', () => {
    expect(chosungIncludes('프론트엔드', 'ㅍㅌ')).toBe(false);
  });

  it('should return true when "ㅍㄹㅌㅇㄷㄱㅂㅈ" is entered for searching "프론트엔드 개발자"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷㄱㅂㅈ')).toBe(true);
  });

  it('should return true when "ㅍㄹㅌㅇㄷ ㄱㅂㅈ" is entered for searching "프론트엔드 개발자"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ')).toBe(true);
  });

  // ...codes
});

import { chosungIncludes } from './chosungIncludes';

describe('chosungIncludes', () => {
  const allTestCases = [
    { search: 'ㅍㄹㅌ', target: '프론트엔드', expected: true },
    { search: 'ㅍㄹㅌ', target: '00프론트엔드', expected: true },
    { search: 'ㅍㄹㅌㅇㄷㄱㅂㅈ', target: '프론트엔드 개발자', expected: true },
    { search: 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ', target: '프론트엔드 개발자', expected: true },
    { search: 'ㅍㅌ', target: '프론트엔드', expected: false },
    { search: '푸롴트', target: '프론트엔드', expected: false },
    { search: 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ', target: ' ', expected: false },
  ];

  it.each(allTestCases)(
    'should return $expected when $search is entered for searching $target',
    ({ search, target, expected }) => {
      expect(chosungIncludes(target, search)).toBe(expected);
    }
  );
});

import { chosungIncludes } from './chosungIncludes';

describe('chosungIncludes', () => {
  describe('초성이 포함되어있다고 판단되는 경우', () => {
    const testCases = [
      { search: 'ㅍㄹㅌ', target: '프론트엔드' },
      { search: 'ㅍㄹㅌ', target: '00프론트엔드' },
      { search: 'ㅍㄹㅌㅇㄷㄱㅂㅈ', target: '프론트엔드 개발자' },
      { search: 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ', target: '프론트엔드 개발자' },
    ];

    it.each(testCases)('should return true when $search is entered for searching $target', ({ search, target }) => {
      const result = chosungIncludes(target, search);

      expect(result).toBe(true);
    });
  });

  describe('초성이 포함되어있다고 판단되지 않는 경우', () => {
    const testCases = [
      { search: 'ㅍㅌ', target: '프론트엔드' },
      { search: '푸롴트', target: '프론트엔드' },
    ];

    it.each(testCases)('should return false when $search is entered for searching $target', ({ search, target }) => {
      const result = chosungIncludes(target, search);

      expect(result).toBe(false);
    });
  });
});

/**
 * 한글 문자열 정확도 계산
 * @param targetText
 * @param inputText
 * @returns 정확도 혹은 철자 오타 갯수?!
 */
function calculateHangulAccuracy(targetText: string,inputText: string): number{
    return 0.4;
}

it('should return true when "ㅍㄹㅌㅇㄷ ㄱㅂㅈ" is entered for searching "프론트엔드"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ')).toBe(true);
 });

const initialConsonantsY = getFirstConsonants(y).replace(/\s/g, '');

chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ')

import { HANGUL_CHARACTERS_BY_FIRST_INDEX } from './constants';
import { disassembleHangulToGroups } from './disassemble';
import { getFirstConsonants, hasValueInReadOnlyStringList } from './utils';

export function chosungIncludes(x: string, y: string) {
  if (!isOnlyInitialConsonant(y)) {
    return false;
  }

  const initialConsonantsX = getFirstConsonants(x).replace(/\s/g, '');
  const initialConsonantsY = getFirstConsonants(y).replace(/\s/g, '');

  return initialConsonantsX.includes(initialConsonantsY);
}

/*
 * @description 공백을 제외한 문자열이 한글초성으로만 주어진 경우
 */
function isOnlyInitialConsonant(str: string) {
  const trimStr = str.replace(/\s/g, '');

  return disassembleHangulToGroups(trimStr).every(disassembled => {
    return disassembled.length === 1 && hasValueInReadOnlyStringList(HANGUL_CHARACTERS_BY_FIRST_INDEX, disassembled[0]);
  });
}

  it('should return true when "ㅍㄹㅌㅇㄷㄱㅂㅈ" is entered for searching "프론트엔드 개발자"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷㄱㅂㅈ')).toBe(true);
  });

  it('should return true when "ㅍㄹㅌㅇㄷ ㄱㅂㅈ" is entered for searching "프론트엔드 개발자"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ')).toBe(true);
  });

const initialConsonantsY = getFirstConsonants(y)

it('should return true when "ㅍㄹㅌㅇㄷ ㄱㅂㅈ" is entered for searching "프론트엔드"', () => {
    expect(chosungIncludes('프론트엔드 개발자', 'ㅍㄹㅌㅇㄷ ㄱㅂㅈ')).toBe(false);
});

// constants.ts
/*
 * 영문 대소문자를 구분한 자판 맵 객체
 */
export const KEBOARD_MAP = {
  q: 'ㅂ',
  Q: 'ㅃ',
  w: 'ㅈ',
  //...한/영 자판 맵핑
} as const;

// convertEnglishToHangul.ts
import { KEBOARD_MAP } from './constants';
import { disassembleHangul } from './disassemble';

/**
 * 영문 자판인 경우 한글 자판으로 치환합니다. 그렇지 않은 경우 입력 문자를 반환합니다. 
 * @param 한글로 변환하고자 하는 영문 자판.
 * @returns 한글 자모로 변환된 문자열
 */
export function convertEngKeboardToHangul(engKeyboardText: string): string {
    return engKeyboardText.split('').map((inputText) => keyboardMap[inputText] ?? disassembleHangul(inputText)).join; 
}

combineHangulCharacter(...convertEngKeboardToHangul('vm').split('')) // Output '프'
combineHangulCharacter(...convertEngKeboardToHangul('fhs').split('')) // Output '론'

import { josa } from "es-hangul";

const word1 = "비고(총수량)";
const word2 = "총수량(비고)";
const word3 = "()";

console.log(josa(word1, "이/가") + " 비어 있습니다.");
console.log(josa(word2, "이/가") + " 비어 있습니다.");
console.log(josa(word3, "이/가") + " 비어 있습니다.");

const word4 = "대지의 여신(이하 가이아)";
const word5 = "가이아(이하 대지의 여신)";
const word6 = "()";

console.log(josa(word4, "을/를") + " 숭배하라");
console.log(josa(word5, "을/를") + " 숭배하라");
console.log(josa(word6, "을/를") + " 숭배하라");

canBeChosung('ㄱ') // true
canBeChosung('ㅃ') // true
canBeChosung('ㄱㅅ') // false
canBeChosung('ㅏ') // false

canBeJungsung('ㅏ') // true
canBeJungsung('ㅗㅏ') // true
canBeJungsung('ㅘ') // false
canBeJungsung('ㄱ') // false

canBeJongsung('ㄱ') // true
canBeJongsung('ㄱㅅ') // true
canBeJongsung('ㅘ') // false
canBeJongsung('ㄹㅍ') // false