import streamlit as st
import pandas as pd
import io, zipfile, re, html, json
from typing import Dict, Tuple

st.set_page_config(page_title="📦 보존상자 라벨 생성기", layout="wide")
st.title("📦 보존상자 라벨 생성기 📦")

# -------------------- 데이터 유틸 --------------------
def _year_range(series: pd.Series) -> str:
    s = series.astype(str).fillna("")
    v = s[~s.isin(["", "0", "0000"])]
    if v.empty: return "0000-0000"
    nums = pd.to_numeric(v, errors="coerce").dropna().astype(int)
    if nums.empty: return "0000-0000"
    return f"{nums.min():04d}-{nums.max():04d}"

def build_rows(df: pd.DataFrame) -> pd.DataFrame:
    df = df.copy()
    df["박스번호"] = df["박스번호"].astype(str).str.zfill(4)
    if "제목" in df.columns:
        df["제목"] = df["제목"].astype(str)

    # 생산연도(범위) = 종료연도 그룹 범위
    if "종료연도" in df.columns:
        yr = df.groupby("박스번호")["종료연도"].apply(_year_range).reset_index()
        yr.columns = ["박스번호", "생산연도"]
    else:
        yr = pd.DataFrame({"박스번호": df["박스번호"].unique(), "생산연도": "0000-0000"})

    # 목록(관리번호 + 제목)
    has_mgmt = "관리번호" in df.columns
    lists = []
    for b, g in df.groupby("박스번호"):
        lines = [f"- {r['관리번호']} {r.get('제목','')}" if has_mgmt else f"- {r.get('제목','')}"
                 for _, r in g.iterrows()]
        lists.append({"박스번호": b, "목록": "\r\n".join(lines)})
    list_df = pd.DataFrame(lists)

    # 대표 메타
    meta_cols = ["박스번호","종료연도","보존기간","단위업무","기록물철","제목"]
    meta_exist = [c for c in meta_cols if c in df.columns]
    meta = df.groupby("박스번호", as_index=False).first()[meta_exist] if meta_exist \
          else pd.DataFrame({"박스번호": df["박스번호"].unique()})

    merged = meta.merge(list_df, on="박스번호", how="left").merge(yr, on="박스번호", how="left")
    return merged

# -------------------- 치환 유틸 --------------------
FIELD_PAIR_RE_TMPL = (
    r'<(?P<fprefix>[a-zA-Z0-9_]+):fieldBegin\b[^>]*\bname="{name}"[^>]*/>'
    r'(.*?)'
    r'<(?P=fprefix):fieldEnd\b[^>]*/>'
)
TOKEN_FMT = "{{{{{key}}}}}"

# 문단(<*:p>) 탐색 패턴
PARA_RE = re.compile(
    r'<(?P<pprefix>[a-zA-Z0-9_]+):p(?P<pattrs>[^>]*)>(?P<pbody>.*?)</(?P=pprefix):p>',
    re.DOTALL
)

# 원본 run 스타일을 추출하는 함수
def _extract_run_style(body: str, pprefix: str) -> str:
    """문단 내용에서 첫 번째 run 요소의 스타일을 추출"""
    run_pattern = re.compile(
        rf'<{pprefix}:run[^>]*>.*?</{pprefix}:run>',
        re.DOTALL
    )
    match = run_pattern.search(body)
    if match:
        return match.group(0)
    return f'<{pprefix}:run><{pprefix}:t><//{pprefix}:t></{pprefix}:run>'

# 문단 하나를 같은 스타일로 복제해주는 헬퍼 (스타일 보존)
def _make_para_with_style(pprefix: str, pattrs: str, text: str, original_run: str) -> str:
    esc = html.escape("" if text is None else str(text))
    
    # 원본 run에서 텍스트 부분만 교체
    text_pattern = re.compile(rf'(<{pprefix}:t[^>]*>)[^<]*(</{pprefix}:t>)')
    new_run = text_pattern.sub(rf'\g<1>{esc}\g<2>', original_run)
    
    # 만약 텍스트 노드가 없다면 기본 형태로
    if new_run == original_run:
        t_pattern = re.compile(rf'(<{pprefix}:run[^>]*>)(.*?)(</{pprefix}:run>)', re.DOTALL)
        new_run = t_pattern.sub(rf'\g<1><{pprefix}:t>{esc}</{pprefix}:t>\g<3>', original_run)
    
    return f'<{pprefix}:p{pattrs}>{new_run}</{pprefix}:p>'

def _split_lines(val) -> list:
    if val is None: return [""]
    return str(val).replace("\r\n","\n").split("\n")

def _replace_para_multiline(xml: str, key: str, value: str, dbg: dict) -> str:
    """
    key가 포함된 '부모 문단 전체'를, 값의 각 줄을 담은 여러 문단으로 교체.
    원본 스타일을 유지하면서 교체.
    """
    pair_pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(key)), re.DOTALL)
    tnode_pat = re.compile(rf'<(?P<p>[a-zA-Z0-9_]+):t[^>]*>[^<]*{re.escape(key)}[^<]*</(?P=p):t>', re.DOTALL)
    token_str = TOKEN_FMT.format(key=key)

    def para_repl(m):
        body = m.group("pbody")
        if not (pair_pat.search(body) or tnode_pat.search(body) or (token_str in body)):
            return m.group(0)

        lines = _split_lines(value)
        pprefix = m.group("pprefix")
        pattrs  = m.group("pattrs")
        
        # 원본 run 스타일 추출
        original_run = _extract_run_style(body, pprefix)
        
        # 각 줄에 대해 원본 스타일을 유지하면서 새 문단 생성
        new_paras = "".join(_make_para_with_style(pprefix, pattrs, ln, original_run) for ln in lines)
        dbg["para_hits"][key] = dbg["para_hits"].get(key, 0) + 1
        return new_paras

    xml2 = PARA_RE.sub(para_repl, xml)
    if xml2 != xml:
        dbg["touched"] = True
    return xml2

def _runs_plain(text: str) -> str:
    return f"<hp:run><hp:t>{html.escape('' if text is None else str(text))}</hp:t></hp:run>"

def _apply_to_xml(xml: str, mapping: Dict[str, str], dbg: dict) -> str:
    changed_any = False

    # 0) 다중줄 키는 먼저 "부모 문단 교체"로 처리 (업무명은 제외하여 폰트 문제 해결)
    multi_key = re.compile(r"^(목록|list|제목)\d+$", re.IGNORECASE)
    for k, v in mapping.items():
        if multi_key.match(k):
            xml_new = _replace_para_multiline(xml, k, v, dbg)
            if xml_new != xml:
                xml = xml_new
                changed_any = True

    # 1) 필드쌍(인라인) 치환 — 단일줄 키만
    for k, v in mapping.items():
        if multi_key.match(k):
            continue
        replacement = _runs_plain(v)
        pat = re.compile(FIELD_PAIR_RE_TMPL.format(name=re.escape(k)), re.DOTALL)
        xml_new, n = pat.subn(replacement, xml)
        if n:
            dbg["field_hits"][k] = dbg["field_hits"].get(k, 0) + n
            xml = xml_new
            changed_any = True

    # 2) 순수 텍스트 자리표시자(<*:t>키</*:t>) 부분치환 — 단일줄 키만
    tnode_all = re.compile(
        r'(<(?P<prefix>[a-zA-Z0-9_]+):t[^>]*>)([^<]*?)</(?P=prefix):t>',
        re.DOTALL
    )
    for k, v in mapping.items():
        if multi_key.match(k):
            continue
        def repl_tnode(m):
            text_node = m.group(3)
            if k not in text_node:
                return m.group(0)
            new_text = html.escape(text_node.replace(k, "" if v is None else str(v)))
            return f"{m.group(1)}{new_text}</{m.group('prefix')}:t>"
        xml2 = tnode_all.sub(repl_tnode, xml)
        if xml2 != xml:
            dbg["text_hits"][k] = dbg["text_hits"].get(k, 0) + 1
            xml = xml2
            changed_any = True

    # 3) 토큰 치환 — 단일줄 키만
    for k, v in mapping.items():
        if multi_key.match(k):
            continue
        tok = TOKEN_FMT.format(key=k)
        if tok in xml:
            xml = xml.replace(tok, html.escape("" if v is None else str(v)))
            dbg["token_hits"][k] = dbg["token_hits"].get(k, 0) + 1
            changed_any = True

    if changed_any:
        dbg["files_touched"] = True
    return xml

def replace_in_hwpx(hwpx_bytes: bytes, mapping: Dict[str,str]) -> Tuple[bytes, dict]:
    import stat, time
    dbg = {"para_hits":{}, "field_hits":{}, "text_hits":{}, "token_hits":{}, "touched_files": []}
    zin = zipfile.ZipFile(io.BytesIO(hwpx_bytes), "r")
    out_buf = io.BytesIO()
    zout = zipfile.ZipFile(out_buf, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=6)

    # 현재 시간
    now = time.localtime()

    # mimetype 무압축 + 맨앞
    names = zin.namelist()
    if "mimetype" in names:
        zi = zipfile.ZipInfo("mimetype")
        zi.compress_type = zipfile.ZIP_STORED
        # 완전히 새로운 ZipInfo로 읽기전용 방지
        zi.external_attr = 0o100666 << 16  # 일반 파일 + 모든 권한
        zi.create_system = 0  # DOS/Windows
        zi.date_time = now[:6]
        zout.writestr(zi, zin.read("mimetype"))

    for e in zin.infolist():
        if e.filename == "mimetype":
            continue
        data = zin.read(e.filename)
        if e.filename.lower().endswith(".xml"):
            try:
                s = data.decode("utf-8", errors="ignore")
                before = s
                s = _apply_to_xml(s, mapping, {"para_hits":dbg["para_hits"], "field_hits":dbg["field_hits"],
                                               "text_hits":dbg["text_hits"], "token_hits":dbg["token_hits"],
                                               "files_touched":False})
                if s != before:
                    dbg["touched_files"].append(e.filename)
                data = s.encode("utf-8")
            except Exception:
                pass
        
        # 완전히 새로운 ZipInfo 생성으로 읽기전용 방지
        zi = zipfile.ZipInfo(e.filename)
        zi.compress_type = zipfile.ZIP_DEFLATED
        zi.external_attr = 0o100666 << 16  # 일반 파일 + 모든 권한
        zi.create_system = 0  # DOS/Windows 시스템
        zi.date_time = now[:6]  # 현재 시간
        zi.flag_bits = 0  # 특별한 플래그 없음
        zout.writestr(zi, data)

    zout.close()
    out_buf.seek(0)
    zin.close()
    return out_buf.getvalue(), dbg

# -------------------- UI --------------------
with st.expander("사용법", expanded=True):
    st.markdown("""
1. 템플릿 파일을 업로드해주세요.
2. 보존상자 정보가 들어있는 엑셀 파일을 업로드해주세요.
3. 출력할 라벨 번호를 선택해주세요.
4. 압축 파일을 다운받고, 압축해제 후 파일을 병합해주세요.
5. 병합 후, 라벨을 출력하세요.
단, 템플릿은 .HWPX(한글) 파일이어야 합니다. (.HWP 불가)
""")

tpl = st.file_uploader("📄 HWPX 템플릿 업로드", type=["hwpx"])
n_per_page = st.number_input("템플릿의 라벨 세트 개수(한 페이지 N개)", 1, 12, 3, 1)
data = st.file_uploader("📊 데이터 업로드 (Excel/CSV)", type=["xlsx","xls","csv"])

if tpl and data:
    tpl_bytes = tpl.read()
    df = pd.read_csv(data) if data.name.lower().endswith(".csv") else pd.read_excel(data)

    if "박스번호" not in df.columns:
        st.error("❌ 필수 컬럼 '박스번호'가 없습니다."); st.stop()

    st.success("✅ 위치 매핑 완료 (엑셀 측)")
    st.dataframe(df.head(10), use_container_width=True)

    merged = build_rows(df)
    boxes = merged["박스번호"].astype(str).str.zfill(4).unique().tolist()

    st.subheader("🔎 업로드된 박스번호 목록")
    st.write(f"총 **{len(boxes)}**개")
    st.dataframe(pd.DataFrame({"박스번호": boxes}), use_container_width=True, height=240)

    sel = st.multiselect("생성할 박스번호 선택 (비우면 전체)", options=boxes)
    work = merged[merged["박스번호"].isin(sel)] if sel else merged
    records = work.sort_values("박스번호").to_dict(orient="records")

    # 1페이지 매핑 프리뷰
    st.subheader("🧪 1페이지 매핑 프리뷰")
    keys = ["박스번호","종료연도","보존기간","단위업무","기록물철","목록","제목","업무명"]
    mapping_preview = {}
    for i in range(int(n_per_page)):
        if i < len(records):
            r = records[i]
            mapping_preview.update({
                f"박스번호{i+1}": r.get("박스번호",""),
                f"종료연도{i+1}": r.get("생산연도",""),
                f"보존기간{i+1}": r.get("보존기간",""),
                f"단위업무{i+1}": r.get("단위업무",""),
                f"기록물철{i+1}": r.get("기록물철",""),
                f"목록{i+1}": r.get("목록",""),
                f"제목{i+1}": r.get("제목",""),
                f"업무명{i+1}": r.get("제목",""),  # 템플릿이 '업무명1'을 쓰는 경우 대응
            })
        else:
            for k in keys: mapping_preview[f"{k}{i+1}"] = ""
    st.dataframe(pd.DataFrame([{"키":k, "값 앞부분":str(v)[:120]} for k,v in sorted(mapping_preview.items())]),
                 use_container_width=True, height=320)

    if st.button("🚀 라벨 생성 (페이지별 HWPX ZIP)"):
        mem = io.BytesIO(); zout = zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED)
        pages = (len(records) + int(n_per_page) - 1) // int(n_per_page)
        debug_all = []

        for p in range(pages):
            chunk = records[p*int(n_per_page):(p+1)*int(n_per_page)]
            mapping = {}
            for i in range(int(n_per_page)):
                if i < len(chunk):
                    r = chunk[i]
                    mapping[f"박스번호{i+1}"] = r.get("박스번호","")
                    mapping[f"종료연도{i+1}"] = r.get("생산연도","")
                    mapping[f"보존기간{i+1}"] = r.get("보존기간","")
                    mapping[f"단위업무{i+1}"] = r.get("단위업무","")
                    mapping[f"기록물철{i+1}"] = r.get("기록물철","")
                    mapping[f"목록{i+1}"]   = r.get("목록","")
                    title_val = r.get("제목","")
                    mapping[f"제목{i+1}"]   = title_val
                    mapping[f"업무명{i+1}"] = title_val
                else:
                    for k in keys: mapping[f"{k}{i+1}"] = ""

            out_hwpx, dbg = replace_in_hwpx(tpl_bytes, mapping)
            debug_all.append({"page": p+1, "stats": dbg})
            name = "_".join([r.get("박스번호","") for r in chunk]) if chunk else f"empty_{p+1}"
            zout.writestr(f"label_{name}.hwpx", out_hwpx)

        zout.close(); mem.seek(0)
        st.download_button("⬇️ ZIP 다운로드", data=mem, file_name="labels_by_page.zip", mime="application/zip")
        st.download_button("⬇️ 디버그(JSON)", data=json.dumps(debug_all, ensure_ascii=False, indent=2),
                           file_name="debug.json", mime="application/json")