#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Step 2: 한약재제품코드 데이터 임포트
"""

import sqlite3
import pandas as pd
from datetime import datetime

def import_product_codes():
    """한약재제품코드 엑셀 파일에서 데이터를 임포트"""

    file_path = 'sample/(게시)한약재제품코드_2510.xlsx'
    sheet_name = '한약재 제품코드_20250930기준(유효코드만 공지)'

    conn = sqlite3.connect('database/kdrug.db')
    cursor = conn.cursor()

    try:
        print("=== 한약재제품코드 데이터 임포트 시작 ===\n")

        # 엑셀 파일 읽기 - 제품코드를 문자열로 유지
        print("1. 엑셀 파일 읽기 중...")
        df = pd.read_excel(file_path, sheet_name=sheet_name,
                          dtype={'제품코드': str, '적용시작일': str, '적용종료일': str})
        print(f"   ✅ {len(df):,}개 데이터 로드 완료")

        # 제품코드 9자리로 패딩
        df['제품코드'] = df['제품코드'].apply(lambda x: str(x).zfill(9) if pd.notna(x) else None)

        # 날짜 형식 변환 (20201120 → 2020-11-20)
        def convert_date(date_str):
            if pd.isna(date_str) or date_str == '99991231':
                return None
            date_str = str(int(date_str))
            return f"{date_str[:4]}-{date_str[4:6]}-{date_str[6:8]}"

        df['valid_from'] = df['적용시작일'].apply(convert_date)
        df['valid_to'] = df['적용종료일'].apply(convert_date)

        # 1. herb_masters 테이블 채우기 (주성분코드별 약재)
        print("\n2. herb_masters 테이블 데이터 임포트...")

        # 유일한 주성분코드 추출
        unique_herbs = df[['주성분코드', '한약재 품목명']].drop_duplicates()
        herb_count = 0

        for _, row in unique_herbs.iterrows():
            if pd.notna(row['주성분코드']):
                try:
                    cursor.execute("""
                        INSERT OR IGNORE INTO herb_masters
                        (ingredient_code, herb_name, is_active)
                        VALUES (?, ?, 1)
                    """, (row['주성분코드'], row['한약재 품목명']))
                    if cursor.rowcount > 0:
                        herb_count += 1
                except Exception as e:
                    print(f"   ⚠️  {row['한약재 품목명']} 임포트 실패: {e}")

        print(f"   ✅ {herb_count}개 약재 마스터 등록 완료")

        # 2. product_companies 테이블 채우기
        print("\n3. product_companies 테이블 데이터 임포트...")

        unique_companies = df['업체명'].unique()
        company_count = 0

        for company in unique_companies:
            if pd.notna(company):
                try:
                    cursor.execute("""
                        INSERT OR IGNORE INTO product_companies
                        (company_name, is_active)
                        VALUES (?, 1)
                    """, (company,))
                    if cursor.rowcount > 0:
                        company_count += 1
                except Exception as e:
                    print(f"   ⚠️  {company} 임포트 실패: {e}")

        print(f"   ✅ {company_count}개 업체 등록 완료")

        # 3. herb_products 테이블 채우기
        print("\n4. herb_products 테이블 데이터 임포트 (시간이 걸릴 수 있습니다)...")

        product_count = 0
        error_count = 0
        batch_size = 1000

        for idx, row in df.iterrows():
            if pd.notna(row['주성분코드']) and pd.notna(row['제품코드']):
                try:
                    # 표준코드와 대표코드를 문자열로 변환
                    standard_code = str(int(row['표준코드'])) if pd.notna(row['표준코드']) else None
                    rep_code = str(int(row['대표코드'])) if pd.notna(row['대표코드']) else None

                    cursor.execute("""
                        INSERT OR IGNORE INTO herb_products
                        (ingredient_code, product_code, company_name, product_name,
                         standard_code, representative_code,
                         package_size, package_unit, valid_from, valid_to, is_active)
                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
                    """, (
                        row['주성분코드'],
                        row['제품코드'],
                        row['업체명'],
                        row['제품명'],
                        standard_code,
                        rep_code,
                        row['약품규격(숫자)'] if row['약품규격(숫자)'] != '-' else None,
                        row['약품규격(단위)'] if row['약품규격(단위)'] != '-' else None,
                        row['valid_from'],
                        row['valid_to']
                    ))
                    if cursor.rowcount > 0:
                        product_count += 1
                except Exception as e:
                    error_count += 1
                    if error_count < 10:  # 처음 10개만 오류 표시
                        print(f"   ⚠️  행 {idx} 임포트 실패: {e}")

            # 진행상황 표시
            if (idx + 1) % batch_size == 0:
                print(f"   ... {idx + 1:,}/{len(df):,} 처리 중 ({product_count:,}개 등록)")
                conn.commit()  # 배치 단위로 커밋

        print(f"   ✅ {product_count:,}개 제품 등록 완료 (오류: {error_count}개)")

        # 4. 기존 herb_items와 매핑
        print("\n5. 기존 herb_items에 ingredient_code 매핑...")

        # 약재명 기준으로 매핑
        cursor.execute("""
            UPDATE herb_items
            SET ingredient_code = (
                SELECT ingredient_code
                FROM herb_masters
                WHERE REPLACE(herb_masters.herb_name, ' ', '') = REPLACE(herb_items.herb_name, ' ', '')
                LIMIT 1
            )
            WHERE ingredient_code IS NULL
        """)
        mapped_count = cursor.rowcount
        print(f"   ✅ {mapped_count}개 약재 매핑 완료")

        # 매핑 확인
        cursor.execute("""
            SELECT COUNT(*) FROM herb_items WHERE ingredient_code IS NOT NULL
        """)
        mapped_total = cursor.fetchone()[0]

        cursor.execute("""
            SELECT COUNT(*) FROM herb_items
        """)
        total_herbs = cursor.fetchone()[0]

        print(f"   📊 매핑 결과: {mapped_total}/{total_herbs} ({mapped_total*100//total_herbs}%)")

        # 매핑되지 않은 약재 확인
        cursor.execute("""
            SELECT herb_name FROM herb_items
            WHERE ingredient_code IS NULL
            ORDER BY herb_name
        """)
        unmapped = cursor.fetchall()

        if unmapped:
            print(f"\n   ⚠️  매핑되지 않은 약재 ({len(unmapped)}개):")
            for herb in unmapped[:10]:  # 처음 10개만 표시
                print(f"      - {herb[0]}")
            if len(unmapped) > 10:
                print(f"      ... 외 {len(unmapped)-10}개")

        conn.commit()

        # 최종 통계
        print("\n=== 임포트 완료 ===")

        # 통계 조회
        cursor.execute("SELECT COUNT(*) FROM herb_masters")
        herb_master_count = cursor.fetchone()[0]

        cursor.execute("SELECT COUNT(*) FROM herb_products")
        product_total = cursor.fetchone()[0]

        cursor.execute("SELECT COUNT(*) FROM product_companies")
        company_total = cursor.fetchone()[0]

        print(f"\n📊 최종 통계:")
        print(f"  • herb_masters: {herb_master_count}개 약재")
        print(f"  • herb_products: {product_total:,}개 제품")
        print(f"  • product_companies: {company_total}개 업체")

        # 샘플 데이터 확인
        print("\n📋 샘플 데이터 (건강):")
        cursor.execute("""
            SELECT p.product_code, p.company_name, p.product_name,
                   p.package_size || COALESCE(' ' || p.package_unit, '') as package
            FROM herb_products p
            JOIN herb_masters m ON p.ingredient_code = m.ingredient_code
            WHERE m.herb_name = '건강'
            LIMIT 5
        """)

        for row in cursor.fetchall():
            print(f"  - [{row[0]}] {row[1]} - {row[2]} ({row[3]})")

    except Exception as e:
        print(f"\n❌ 오류 발생: {e}")
        conn.rollback()
        raise
    finally:
        conn.close()

if __name__ == "__main__":
    import time
    start = time.time()
    import_product_codes()
    elapsed = time.time() - start
    print(f"\n⏱️  실행 시간: {elapsed:.2f}초")