AzooKeyKanaKanjiConverter/Sources/SwiftUtils/CharacterUtils.swift

//
//  extension Character.swift
//  Keyboard
//
//  Created by ensan on 2020/09/03.
//  Copyright © 2020 ensan. All rights reserved.
//

import Foundation

public enum CharacterUtils {
    /// 小書きのかなカナ集合
    private static let kogakiKana: Set<Character> = [
        "ぁ", "ぃ", "ぅ", "ぇ", "ぉ", "ゕ", "ゖ", "っ", "ゃ", "ゅ", "ょ", "ゎ",
        "ァ", "ィ", "ゥ", "ェ", "ォ", "ヵ", "ヶ", "ッ", "ャ", "ュ", "ョ", "ヮ"
    ]
    /// 濁点付きのかなカナ集合
    private static let dakutenKana: Set<Character> = [
        "ゔ", "が", "ぎ", "ぐ", "げ", "ご", "ざ", "じ", "ず", "ぜ", "ぞ", "だ", "ぢ", "づ", "で", "ど", "ば", "び", "ぶ", "べ", "ぼ",
        "ヴ", "ガ", "ギ", "グ", "ゲ", "ゴ", "ザ", "ジ", "ズ", "ゼ", "ゾ", "ダ", "ヂ", "ヅ", "デ", "ド", "バ", "ビ", "ブ", "ベ", "ボ"
    ]

    /// 小書きかなか否か
    static func isKogana(_ character: Character) -> Bool {
        kogakiKana.contains(character)
    }

    /// ローマ字(a-z, A-Zか否か)
    @inlinable public static func isRomanLetter(_ character: Character) -> Bool {
        character.isASCII && character.isCased
    }

    /// 自分が小書きであれば該当する文字を返す。
    public static func kogaki(_ character: Character) -> Character {
        switch character {
        case "あ": return "ぁ"
        case "い": return "ぃ"
        case "う": return "ぅ"
        case "え": return "ぇ"
        case "お": return "ぉ"
        case "か": return "ゕ"
        case "け": return "ゖ"
        case "つ": return "っ"
        case "や": return "ゃ"
        case "ゆ": return "ゅ"
        case "よ": return "ょ"
        case "わ": return "ゎ"
        case "ア": return "ァ"
        case "イ": return "ィ"
        case "ウ": return "ゥ"
        case "エ": return "ェ"
        case "オ": return "ォ"
        case "カ": return "ヵ"
        case "ケ": return "ヶ"
        case "ツ": return "ッ"
        case "ヤ": return "ャ"
        case "ユ": return "ュ"
        case "ヨ": return "ョ"
        case "ワ": return "ヮ"
        default: return character
        }
    }

    /// 小書きから大書きを返す
    public static func ogaki(_ character: Character) -> Character {
        switch character {
        case "ぁ": return "あ"
        case "ぃ": return "い"
        case "ぅ": return "う"
        case "ぇ": return "え"
        case "ぉ": return "お"
        case "ゕ": return "か"
        case "ゖ": return "け"
        case "っ": return "つ"
        case "ゃ": return "や"
        case "ゅ": return "ゆ"
        case "ょ": return "よ"
        case "ゎ": return "わ"
        case "ァ": return "ア"
        case "ィ": return "イ"
        case "ゥ": return "ウ"
        case "ェ": return "エ"
        case "ォ": return "オ"
        case "ヵ": return "カ"
        case "ヶ": return "ケ"
        case "ッ": return "ツ"
        case "ャ": return "ヤ"
        case "ュ": return "ユ"
        case "ョ": return "ヨ"
        case "ヮ": return "ワ"
        default: return character
        }
    }

    /// 濁点付きか否か
    public static func isDakuten(_ character: Character) -> Bool {
        dakutenKana.contains(character)
    }
    /// 濁点をつけて返す
    public static func dakuten(_ character: Character) -> Character {
        switch character {
        case"う": return "ゔ"
        case"か": return "が"
        case"き": return "ぎ"
        case"く": return "ぐ"
        case"け": return "げ"
        case"こ": return "ご"
        case"さ": return "ざ"
        case"し": return "じ"
        case"す": return "ず"
        case"せ": return "ぜ"
        case"そ": return "ぞ"
        case"た": return "だ"
        case"ち": return "ぢ"
        case"つ": return "づ"
        case"て": return "で"
        case"と": return "ど"
        case"は": return "ば"
        case"ひ": return "び"
        case"ふ": return "ぶ"
        case"へ": return "べ"
        case"ほ": return "ぼ"
        case"ウ": return "ヴ"
        case"カ": return "ガ"
        case"キ": return "ギ"
        case"ク": return "グ"
        case"ケ": return "ゲ"
        case"コ": return "ゴ"
        case"サ": return "ザ"
        case"シ": return "ジ"
        case"ス": return "ズ"
        case"セ": return "ゼ"
        case"ソ": return "ゾ"
        case"タ": return "ダ"
        case"チ": return "ヂ"
        case"ツ": return "ヅ"
        case"テ": return "デ"
        case"ト": return "ド"
        case"ハ": return "バ"
        case"ヒ": return "ビ"
        case"フ": return "ブ"
        case"ヘ": return "ベ"
        case"ホ": return "ボ"
        default: return character
        }
    }
    /// 濁点を外して返す
    public static func mudakuten(_ character: Character) -> Character {
        switch character {
        case"ゔ": return "う"
        case"が": return "か"
        case"ぎ": return "き"
        case"ぐ": return "く"
        case"げ": return "け"
        case"ご": return "こ"
        case"ざ": return "さ"
        case"じ": return "し"
        case"ず": return "す"
        case"ぜ": return "せ"
        case"ぞ": return "そ"
        case"だ": return "た"
        case"ぢ": return "ち"
        case"づ": return "つ"
        case"で": return "て"
        case"ど": return "と"
        case"ば": return "は"
        case"び": return "ひ"
        case"ぶ": return "ふ"
        case"べ": return "へ"
        case"ぼ": return "ほ"
        case"ヴ": return "ウ"
        case"ガ": return "カ"
        case"ギ": return "キ"
        case"グ": return "ク"
        case"ゲ": return "ケ"
        case"ゴ": return "コ"
        case"ザ": return "サ"
        case"ジ": return "シ"
        case"ズ": return "ス"
        case"ゼ": return "セ"
        case"ゾ": return "ソ"
        case"ダ": return "タ"
        case"ヂ": return "チ"
        case"ヅ": return "ツ"
        case"デ": return "テ"
        case"ド": return "ト"
        case"バ": return "ハ"
        case"ビ": return "ヒ"
        case"ブ": return "フ"
        case"ベ": return "ヘ"
        case"ボ": return "ホ"
        default: return character
        }
    }
    /// 半濁点かどうか
    public static func isHandakuten(_ character: Character) -> Bool {
        [
            "ぱ", "ぴ", "ぷ", "ぺ", "ぽ",
            "パ", "ピ", "プ", "ペ", "ポ"
        ].contains(character)
    }
    /// 半濁点をつけて返す
    public static func handakuten(_ character: Character) -> Character {
        switch character {
        case"は": return "ぱ"
        case"ひ": return "ぴ"
        case"ふ": return "ぷ"
        case"へ": return "ぺ"
        case"ほ": return "ぽ"
        case"ハ": return "パ"
        case"ヒ": return "ピ"
        case"フ": return "プ"
        case"ヘ": return "ペ"
        case"ホ": return "ポ"
        default: return character
        }
    }
    /// 半濁点を外して返す
    public static func muhandakuten(_ character: Character) -> Character {
        switch character {
        case"ぱ": return "は"
        case"ぴ": return "ひ"
        case"ぷ": return "ふ"
        case"ぺ": return "へ"
        case"ぽ": return "ほ"
        case"パ": return "ハ"
        case"ピ": return "ヒ"
        case"プ": return "フ"
        case"ペ": return "ヘ"
        case"ポ": return "ホ"
        default: return character
        }
    }

    /// 濁点、小書き、半濁点などを相互に変換する関数。
    public static func requestChange(_ character: Character) -> String {
        if character.isLowercase {
            return character.uppercased()
        }
        if character.isUppercase {
            return character.lowercased()
        }

        if Set(["あ", "い", "え", "お", "や", "ゆ", "よ", "わ"]).contains(character) {
            return String(kogaki(character))
        }

        if Set(["ぁ", "ぃ", "ぇ", "ぉ", "ゃ", "ゅ", "ょ", "ゎ"]).contains(character) {
            return String(ogaki(character))
        }

        if Set(["か", "き", "く", "け", "こ", "さ", "し", "す", "せ", "そ", "た", "ち", "て", "と"]).contains(character) {
            return String(dakuten(character))
        }

        if Set(["が", "ぎ", "ぐ", "げ", "ご", "ざ", "じ", "ず", "ぜ", "ぞ", "だ", "ぢ", "で", "ど"]).contains(character) {
            return String(mudakuten(character))
        }

        if Set(["つ", "う"]).contains(character) {
            return String(kogaki(character))
        }

        if Set(["っ", "ぅ"]).contains(character) {
            return String(dakuten(ogaki(character)))
        }

        if Set(["づ", "ゔ"]).contains(character) {
            return String(mudakuten(character))
        }

        if Set(["は", "ひ", "ふ", "へ", "ほ"]).contains(character) {
            return String(dakuten(character))
        }

        if Set(["ば", "び", "ぶ", "べ", "ぼ"]).contains(character) {
            return String(handakuten(mudakuten(character)))
        }

        if Set(["ぱ", "ぴ", "ぷ", "ぺ", "ぽ"]).contains(character) {
            return String(muhandakuten(character))
        }

        return String(character)
    }
}

public extension Character {
    /// Returns the Katakanized version of the character.
    @inlinable func toKatakana() -> Character {
        if self.unicodeScalars.count != 1 {
            return self
        }
        let scalar = self.unicodeScalars.first!
        if 0x3041 <= scalar.value && scalar.value <= 0x3096 {
            return Character(UnicodeScalar(scalar.value + 96)!)
        } else {
            return self
        }
    }

    /// Returns the Hiraganized version of the character.
    @inlinable func toHiragana() -> Character {
        if self.unicodeScalars.count != 1 {
            return self
        }
        let scalar = self.unicodeScalars.first!
        if 0x30A1 <= scalar.value && scalar.value <= 0x30F6 {
            return Character(UnicodeScalar(scalar.value - 96)!)
        } else {
            return self
        }
    }
}