const keys = {
  g: "あかさたなはまやらわがざだばぱ".split``,
  d: "あいうえお".split``,
  nn: ["ん"],
  kmj: ["小文字化"],
  okb: ["この前に"] // 🆕
}//for <label> & srctxts
const {kn2abMap,ab2kkMap,kk2abMap,ab2knMap,hrktMp} = aMap(keys)

const [gs, ds, nn, kmj, okb] = ["g", "d", "nn", "kmj", "okb"].map((x) =>
  Object.fromEntries(keys[x].map((k) => [k, ""]))
);

const midasi = [{ g: "【行】"}, {d: "【段】" }]
  .reduce((a,c,i)=>{
    const k = Object.keys(c)[0]
    return {...a,[k]:{txt:c[k]}}
  },{})

const {vsm,emm,zwj} = xxm()
  
const { createApp, reactive } = PetiteVue;
const store = reactive({
  gs,ds,nn,kmj,okb,
  open_cheatsheet:false,
  open_table:false,open_zkb:false,open_xsbr:false,
  conv_opts:{
    hn2zn: true,
    hrkt: "hr",
    kmmv: true
  },
  srctxts:{zk:""},
  ta:{kn:"",zk:""},zkbks:[],
  sample: "こんにちは"
});
createApp({ store }).mount();

function preset_btn(props) {
  const { label, key } = props;
  return {
    $template: "#preset",
    label, key,
    fill() {fill_table(key);zkbg()}
  };
}
function fill_table(key) {
  set_table(store.srctxts[key])
}

function set_table(srctxt) {
  const ls = srctxt.split(/[\n\r]+/);
  const dstart = ls.findIndex(l => l.match(midasi.d.txt));
  const gstart = ls.findIndex(l => l.match(midasi.g.txt));
  ls.forEach((l, li) => {
    if (l.indexOf`\t` > 0) {
      const [k, v] = l.split`\t`;
      //if (keys.nn[0]==k || keys.kmj[0]==k) {
      if (["nn","kmj","okb"].some(n=>keys[n][0]==k)){
        store[["nn","kmj","okb"].find(n=>keys[n][0]==k)][k] = v;
      } else {
        store[(
          (gstart<dstart&&gstart<li&&li<dstart)||
          (dstart<gstart&&gstart<li)?"g":"d"
          )+"s"][k] = v;
      }
    }
  });
}

function s2cp_(str) {
  let r="";for(const s of str){r+=s.codePointAt(0)+"_"}
  return r
}

function xsbr(f,t) { // “batch/bulk” replace
  //const {gs,ds,nn,kmj} = store
  ["gs","ds","nn","kmj","okb"].forEach(x=>{
    for (let [k,v] of Object.entries(store[x])) {
      store[x][k] = v.replaceAll(f,t)
    }
  })
}

function aMap(keys) {
  const mapsrctxt = `
あア→.a;いイ→.i;うウ→.u;えエ→.e;おオ→.o;
かカ→ka;きキ→ki;くク→ku;けケ→ke;こコ→ko;
さサ→sa;しシ→si;すス→su;せセ→se;そソ→so;
たタ→ta;ちチ→ti;つツ→tu;てテ→te;とト→to;
なナ→na;にニ→ni;ぬヌ→nu;ねネ→ne;のノ→no;
はハ→ha;ひヒ→hi;ふフ→hu;へヘ→he;ほホ→ho;
まマ→ma;みミ→mi;むム→mu;めメ→me;もモ→mo;
やヤ→ya;ゆユ→yu;よヨ→yo;
らラ→ra;りリ→ri;るル→ru;れレ→re;ろロ→ro;
わワ→wa;ゐヰ→wi;ゑヱ→we;をヲ→wo;
んン→q;
がガ→ga;ぎギ→gi;ぐグ→gu;げゲ→ge;ごゴ→go;
ざザ→za;じジ→zi;ずズ→zu;ぜゼ→ze;ぞゾ→zo;
だダ→da;ぢヂ→di;づヅ→du;でデ→de;どド→do;
ばバ→ba;びビ→bi;ぶブ→bu;べベ→be;ぼボ→bo;
ぱパ→pa;ぴピ→pi;ぷプ→pu;ぺペ→pe;ぽポ→po;
ぁァ→.!a;ぃィ→.!i;ぅゥ→.!u;ぇェ→.!e;ぉォ→.!o;
ゃャ→y!a;ゅュ→y!u;ょョ→y!o;
っッ→t!u;
  `.trim()
  const kn2abMap = new Map(), hrktMp=new Map()
  mapsrctxt.split(/;\s?/)
    .map(v=>v.split`→`)
    .forEach(([ks,v])=>{
      const x = ks.split``, y=[true,false]
      x.forEach(k=>{kn2abMap.set(k,v)})
      y.forEach(i=>hrktMp.set(x[i?0:1],x[i?1:0]))
    })
  const ab2kkMap = new Map();
  ["g:.kstnhmyrwgzdbp","d:aiueo","nn:q","kmj:!"]
    .map(v=>v.split`:`)
    .forEach(([k,s])=>{s.split``.forEach((v,idx)=>{
      ab2kkMap.set(v,[
        k+(k=="g"||k=="d"?"s":""),
        keys[k][idx]
      ])
    })})
  const n_=new Map();ab2kkMap.forEach((v,k)=>{n_.set(v.join`,`,k)});const kk2abMap = n_;
  const o_=new Map();kn2abMap.forEach((v,k)=>{if(/[ぁ-ん]/.test(k))o_.set(v,k)});const ab2knMap = o_;
  return {kn2abMap,ab2kkMap,kk2abMap,ab2knMap,hrktMp}
}

function kn2zk(
  text,st,
  k2aM=kn2abMap,a2kM=ab2kkMap
){
  st=st?st:store;
  const {conv_opts} = st
  const {hn2zn,kmmv} = conv_opts
  const srctext0 = hn2zn?hntxt2zntxt(text):text
  const srctext = nobasi2vowel(srctext0)
  const replacer = moji => {
    const ab = k2aM.get(moji)
    const tbj = ab ? ab.split``
      .map(a=>a2kM.get(a))
      .map(kk=>st[kk[0]][kk[1]])
      :null
    return !tbj?moji:kmmv&&ab[1]=="!"?
      kzrp_kmmv(tbj):
      tbj.join``
  }
  return srctext.replace(/[ァ-ンぁ-ん]/g,replacer)
}
function kzrp_kmmv(tbj){
  const [gy,kj,dn] = tbj
  const okb_s = store.okb[keys.okb[0]]
  const dkjn = dn.replace(okb_s,kj+okb_s)
  return dkjn.match(okb_s)?gy+dkjn:gy+kj+dn
}

function hntxt2zntxt(hntxt) {
  return hntxt.replace(/[｡-ﾟ]+/g,m=>m.normalize("NFKC")).toString()
}

function nobasi2vowel(text,k2aM=kn2abMap) {
  k2aM=k2aM?k2aM:kn2abMap
  return text.replace(
    /([ァ-ンぁ-ん])(ー+)/g,(_,kn,nbs)=>{
      const ab = k2aM.get(kn)
      const b = ab?ab.slice(-1)[0]:null
      const tbl = {a:"あ",i:"い",u:"う",e:"え",o:"お"}
      const result = b?tbl[b]?tbl[b]:kn:ー
      return [kn,nbs.replace(/./g,result)].join``}
  ).toString()
}

function zk2kn(
  text_in,st,
  kkab=kk2abMap,abkn=ab2knMap
){
  st=st?st:store;
  const {conv_opts,gs,ds,nn,kmj,okb} = st
  const {hrkt,kmmv} = conv_opts
  const zkkk = new Map() // nonce Map()
  //regexp
  const [pg,pd,pn,pk] = [{gs},{ds},{nn},{kmj}]
    .map(o0=>{
      const [k,o] = Object.entries(o0)[0]
      return Object.entries(o).map(([l,z])=>{
        zkkk.set(z,[k,l].join`,`)
        return escstr(z)
      })
    })
  //(kmmv? undo komoji-move)
  const dkjn2zkM = !kmmv?null:d2z_gen(ds,kmj,okb)
  const text = !kmmv?text_in:nomrepwitMap(text_in,dkjn2zkM)
  //([nn]|[pg][kmj]?[pd])
  const restr = `
    (${pn[0]})|(?!${pd.join`|`})((${pg.join`|`})(${pk[0]})?(${pd.join`|`}))(?!${pd.join`|`})
    `.trim()
  const re = new RegExp(restr,"g")
  //replacer
  return text.replace(re,(_m,mn,__,mg,mk,md)=>{
    //console.log({mn,mg,mk,md})
    const abcd = [mn,mg,mk,md].filter(_=>_).map(m=>
      kkab.get(zkkk.get(m))
    ).join``
    const hrgn = abkn.get(abcd)
    const knkn = hrkt=="hr"?hrgn:hrktMp.get(hrgn)
    return knkn?knkn:_m
  })
}
function escstr(str) { if(!str) return null
  const sp = /[\[\\\^\$\.\|\?\*\+\(\)]/g
  return str.replace(sp,"\\$&").toString()
}// for RegExp
function d2z_gen(ds_,kmj_,okb_) {
  const o_s = okb_[keys.okb[0]]
  const k_s = kmj_[keys.kmj[0]]
  const dkjn2zkM = new Map()
  Object.values(ds_).forEach(zd=>{
    dkjn2zkM.set(zd.replace(o_s,k_s+o_s),k_s+zd)
  })
  return dkjn2zkM
}
function nomrepwitMap(text,_Map) {
  const re0 = [..._Map.keys()].join`|`
  return text.replace(
    new RegExp(`(${re0})`,"g"),
    match=>_Map.get(match)
  )
}

//for key<button>s

function xxm() {
  const vsm = /[\u{fe00}-\u{fe0f}\u{e0100}-\u{e01ef}]/u
  const emm = /[\u{1f3fb}-\u{1f3ff}\u{200d}]/u
  const zwj = "\u{200d}"
  // flags not supported
  return {vsm,emm,zwj}
}
function ss(str) {
  let r = [], pre_z=false
  for (const c of str) {
    r.push(
      (vsm.test(c)||emm.test(c)||pre_z)&&r[0]?
        r.pop().concat(c):
        c)
    pre_z = zwj==c
  }
  return r
}
function zkbg() {
  let pre_z = false, last = ""
  const {gs,ds,nn,kmj} = store
  const charS = new Set()
  for (const o of [gs,ds,nn,kmj]) {
    for (const v of Object.values(o)) {
      for (const c of v) {
        if (vsm.test(c)||emm.test(c)||pre_z) {
          charS.delete(last);
          charS.add(last+c);last=last+c
        }else{charS.add(c);last=c}
        pre_z = zwj==c
  }}}
  store.zkbks.splice(0)
  charS.forEach(c=>{store.zkbks.push(c)})
}
function zkbk(props) {
  const { label, text } = props;
  return {
    $template: "#zkbk",
    label, text,
    put() {store.ta.zk+=text}
  }
}

function bszk() { //"backspace"
  const tarr = [...store.ta.zk]
  const popt = tarr.pop()
  if(vsm.test(popt)||emm.test(popt)||tarr.slice(-1)[0]==zwj){tarr.pop()}
  store.ta.zk = tarr.join``
}

function udt_zk() {store.ta.zk=kn2zk(store.ta.kn)}
function udt_kn() {store.ta.kn=zk2kn(store.ta.zk)}

//init

function reg(elm,key,init_with=false) {
  const srctxt = elm.text
  store.srctxts[key] = srctxt
  if(init_with){
    fill_table(key)
    zkbg()
  }
}