#!/usr/bin/env node

function getDigitFromRight(numberString, indexFromRight) {
  if (indexFromRight < 0) {
    throw new Error('you should not be here')
  }
  if (indexFromRight >= numberString.length) {
    return 0
  }
  return parseInt(numberString[numberString.length - 1 - indexFromRight])
}

// test('getDigitFromRight', () => {
//   expect(getDigitFromRight('649', 0)).toBe(9)
//   expect(getDigitFromRight('649', 1)).toBe(4)
//   expect(getDigitFromRight('649', 2)).toBe(6)
// })
// test('return 0 when out of range', () => {
//   expect(getDigitFromRight('649', 3)).toBe(0)
// })

function add(a = '' /*string*/, b = '' /*string*/) {
  let longNumberString = a
  let shortNumberString = b
  if (b.length > a.length) {
    longNumberString = b
    shortNumberString = a
  }

  let carry = 0
  let answer = ''

  for (let index = 0; index < longNumberString.length; index++) {
    const upDigit = getDigitFromRight(longNumberString, index)
    const downDigit = getDigitFromRight(shortNumberString, index)

    const digitSum = upDigit + downDigit + carry
    answer = (digitSum % 10).toString() + answer
    carry = Math.floor(digitSum / 10)
  }

  if (carry !== 0) {
    answer = carry.toString() + answer
  }

  return answer
}

// test('add', () => {
//   expect(add('0', '0')).toBe('0')
//   expect(add('0', '2')).toBe('2')
//   expect(add('1', '2')).toBe('3')
//   expect(add('10', '2')).toBe('12')
//   expect(add('10', '200')).toBe('210')
//   expect(add('96', '4')).toBe('100')
//   expect(add('960700081327001', '43520069100001')).toBe('1004220150427002')
// })
// test('add big int', () => {
//   expect(add('9007199254740991', '9007199254740991')).toBe('18014398509481982')
//   expect(add('9007199254740991', '9007199')).toBe('9007199263748190')
//   expect(add('9007199254740991', '90071992547409919007199254740991')).toBe('90071992547409928014398509481982')
// })

const DIGITS_IN_KOREAN = '일이삼사오육칠팔구'
const MAGNITUDES = {
  십: 1, // 10^1 = 10
  백: 2,
  천: 3,
  만: 4,
  억: 8,
  조: 12,
}

function koreanToNumberString(koreanString) {
  const KOREAN_TO_DIGIT = {}
  DIGITS_IN_KOREAN.split('').forEach((char, index) => {
    KOREAN_TO_DIGIT[char] = index + 1
  })

  let numString = ''

  for (let indexFromRight = koreanString.length - 1; indexFromRight >= 0; indexFromRight--) {
    const char = koreanString[indexFromRight]
    if (typeof KOREAN_TO_DIGIT[char] !== 'undefined') {
      numString = KOREAN_TO_DIGIT[char].toString() + numString
    } else if (typeof MAGNITUDES[char] !== 'undefined') {
      if (MAGNITUDES[char] < 4) {
        numString = numString.padStart(Math.floor(numString.length / 4) * 4 + MAGNITUDES[char], '0')
      } else {
        numString = numString.padStart(MAGNITUDES[char], '0')
      }

      if (
        indexFromRight !== 0 &&
        typeof MAGNITUDES[koreanString[indexFromRight - 1]] !== 'undefined' &&
        MAGNITUDES[koreanString[indexFromRight - 1]] > MAGNITUDES[char]
      ) {
        numString = '1' + numString
      }
    } else {
      throw new Error(`unknown character ${char}`)
    }
  }

  if (typeof MAGNITUDES[koreanString[0]] !== 'undefined') {
    numString = '1' + numString
  }

  return numString
}

const TEST_CASES = {
  일: '1',
  구: '9',
  십: '10',
  이십: '20',
  십일: '11',
  십일: '11',
  천백십일: '1111',
  십: '10',
  일조: '1000000000000',
  일억: '100000000',
  십만: '100000',
  천십만: '10100000',
  백십만: '1100000',
  천백십만: '11100000',
  일조일억일만: '1000100010000',
  오백삼십조칠천팔백구십만천오백삼십구: '530000078901539',
  삼조사천이만삼천구: '3000040023009',
  육십사억삼천십팔만칠천육백구: '6430187609',
  사십삼: '43',

  // big int
  구천칠조천구백구십이억오천사백칠십사만구백구십일: '9007199254740991',
  구천칠조천구백구십이억오천사백칠십사만구백구십칠: '9007199254740997',
  구천칠조천구백구십이억오천사백칠십사만구백구십구: '9007199254740999',
  구천구백구십구조구천구백구십구억구천구백구십구만구천구백구십구: '9999999999999999',
}

// test.each(Object.entries(TEST_CASES))('%s -> %s', (korean, expected) => {
//   expect(koreanToNumberString(korean)).toBe(expected)
// })

function numberStringToKorean(numberString) {
  if (numberString.length > 16) {
    throw new Error('Cannot express. 일경 미만의 숫자만 표현 가능합니다.')
  }

  const DIGIT_TO_KOREAN = {}
  DIGITS_IN_KOREAN.split('').forEach((char, index) => {
    DIGIT_TO_KOREAN[index + 1] = char
  })

  const EVERY_FOURTH = ['만', '억', '조']
  const INSIDE_FOURTH = ['십', '백', '천']

  let answer = ''

  for (let index = 0; index < numberString.length; index++) {
    const numChar = numberString[index]

    if (numChar !== '0') {
      if (numChar !== '1' || (numberString.length - 1 - index) % 4 === 0) {
        answer += DIGIT_TO_KOREAN[numChar]
      }
      if ((numberString.length - 1 - index) % 4 !== 0) {
        answer += INSIDE_FOURTH[((numberString.length - 1 - index) % 4) - 1]
      }
    }
    if (numberString.length - index - 1 !== 0 && (numberString.length - index - 1) % 4 === 0) {
      if (answer.length > 0 && !(answer[answer.length - 1] === '조' || answer[answer.length - 1] === '억')) {
        answer += EVERY_FOURTH[(numberString.length - index - 1) / 4 - 1]
      }
    }
  }

  if (answer.length !== 2 && answer.slice(0, 2) === '일만') {
    return answer.slice(1)
  }

  return answer
}

// test('numberStringToKorean', () => {
//   expect(numberStringToKorean('1')).toBe('일')
//   expect(numberStringToKorean('9')).toBe('구')
//   expect(numberStringToKorean('39')).toBe('삼십구')
//   expect(numberStringToKorean('109')).toBe('백구')
//   expect(numberStringToKorean('1701')).toBe('천칠백일')
//   expect(numberStringToKorean('10000')).toBe('일만')
//   expect(numberStringToKorean('100000')).toBe('십만')
//   expect(numberStringToKorean('110000')).toBe('십일만')
//   expect(numberStringToKorean('110011')).toBe('십일만십일')
//   expect(numberStringToKorean('1000000000000')).toBe('일조')
//   expect(numberStringToKorean('1004')).toBe('천사')
//   expect(numberStringToKorean('10040000')).toBe('천사만')
//   expect(numberStringToKorean('100400000000')).toBe('천사억')
//   expect(numberStringToKorean('1004000000000000')).toBe('천사조')
// })

// test.each(Object.entries(TEST_CASES).map(a => a.reverse()))('%s -> %s', (numString, expected) => {
//   expect(numberStringToKorean(numString)).toBe(expected)
// })

function addKorean(a, b) {
  return numberStringToKorean(add(koreanToNumberString(a), koreanToNumberString(b)))
}

// test('addKorean', () => {
//   expect(addKorean('구백육십조칠천억팔천백삼십이만칠천일', '사십삼조오천이백억육천구백십만일')).toBe(
//     '천사조이천이백일억오천사십이만칠천이',
//   )
//   expect(addKorean('일', '이')).toBe('삼')
// })

// test('problem test case', () => {
//   expect(addKorean('오백삼십조칠천팔백구십만천오백삼십구', '삼조사천이만삼천구')).toBe(
//     '오백삼십삼조일억천팔백구십이만사천오백사십팔',
//   )
//   expect(addKorean('육십사억삼천십팔만칠천육백구', '사십삼')).toBe('육십사억삼천십팔만칠천육백오십이')
//   expect(addKorean('이천구백육십조천오백칠십만삼천구백구십', '삼천사백오십조일억이천만육백사십삼')).toBe(
//     '육천사백십조일억삼천오백칠십만사천육백삼십삼',
//   )
//   expect(addKorean('사십오억삼천육십만오백구십', '칠십억천이백삼십오만칠천구십이')).toBe(
//     '백십오억사천이백구십오만칠천육백팔십이',
//   )
//   expect(addKorean('오억사천', '백십일')).toBe('오억사천백십일')
//   expect(addKorean('만오천사백삼십', '십구만삼천오백')).toBe('이십만팔천구백삼십')
//   expect(addKorean('일조', '삼')).toBe('일조삼')
//   expect(addKorean('일억', '만')).toBe('일억일만')

//   expect(addKorean('구백육십조칠천억팔천백삼십이만칠천일', '사십삼조오천이백억육천구백십만일')).toBe(
//     '천사조이천이백일억오천사십이만칠천이',
//   )
//   expect(addKorean('천백십일', '구천오백구십구')).toBe('만칠백십')
// })

const args = process.argv.slice(2)
console.log(addKorean(args[0], args[1]))