app.py

import pandas as pd
import streamlit as st
import matplotlib.pyplot as plt
import matplotlib.font_manager as font_manager
import io
import base64
import os
from datetime import datetime, timedelta
import math
from matplotlib.patches import FancyBboxPatch, Rectangle
from pypinyin import lazy_pinyin, Style
from matplotlib.backends.backend_pdf import PdfPages

def get_font(size=14):
    """Loads the specified font file, falling back to a default."""
    font_path = "simHei.ttc"
    if not os.path.exists(font_path):
        font_path = "SimHei.ttf"
    if not os.path.exists(font_path):
        # As a last resort, return default font if SimHei is not found
        st.warning("Font file 'simHei.ttc' or 'SimHei.ttf' not found. Text may not render correctly.")
        return font_manager.FontProperties(size=size)
    return font_manager.FontProperties(fname=font_path, size=size)

def get_pinyin_abbr(text):
    """Gets the first letter of the Pinyin for the first two Chinese characters."""
    if not text:
        return ""
    chars = [c for c in text if '\u4e00' <= c <= '\u9fff'][:2]
    if not chars:
        return ""
    return ''.join(lazy_pinyin(chars, style=Style.FIRST_LETTER)).upper()

def process_schedule(file):
    """Reads and processes the movie schedule from the uploaded Excel file."""
    try:
        # Try to read the date from a specific cell
        date_df = pd.read_excel(file, header=None, skiprows=7, nrows=1, usecols=[3])
        date_str = pd.to_datetime(date_df.iloc[0, 0]).strftime('%Y-%m-%d')
        base_date = pd.to_datetime(date_str).date()
    except Exception:
        # Fallback to today's date
        base_date = datetime.today().date()
        date_str = base_date.strftime('%Y-%m-%d')

    try:
        df = pd.read_excel(file, header=9, usecols=[1, 2, 4, 5])
        df.columns = ['Hall', 'StartTime', 'EndTime', 'Movie']
        df['Hall'] = df['Hall'].ffill()
        df.dropna(subset=['StartTime', 'EndTime', 'Movie'], inplace=True)
        df['Hall'] = df['Hall'].astype(str).str.extract(r'(\d+号)')
        df.dropna(subset=['Hall'], inplace=True)

        # Convert times to datetime objects
        df['StartTime_dt'] = pd.to_datetime(df['StartTime'], format='%H:%M', errors='coerce').apply(
            lambda t: t.replace(year=base_date.year, month=base_date.month, day=base_date.day) if pd.notnull(t) else t
        )
        df['EndTime_dt'] = pd.to_datetime(df['EndTime'], format='%H:%M', errors='coerce').apply(
            lambda t: t.replace(year=base_date.year, month=base_date.month, day=base_date.day) if pd.notnull(t) else t
        )
        # Handle overnight screenings
        df.loc[df['EndTime_dt'] < df['StartTime_dt'], 'EndTime_dt'] += timedelta(days=1)
        df = df.sort_values(['Hall', 'StartTime_dt'])

        # Merge consecutive shows of the same movie
        merged_rows = []
        for hall, group in df.groupby('Hall'):
            current = None
            for _, row in group.sort_values('StartTime_dt').iterrows():
                if current is None:
                    current = row.copy()
                elif row['Movie'] == current['Movie']:
                    current['EndTime_dt'] = row['EndTime_dt']
                else:
                    merged_rows.append(current)
                    current = row.copy()
            if current is not None:
                merged_rows.append(current)

        if not merged_rows:
            return None, date_str
            
        merged_df = pd.DataFrame(merged_rows)
        
        # Adjust times as per original logic
        merged_df['StartTime_dt'] -= timedelta(minutes=10)
        merged_df['EndTime_dt'] -= timedelta(minutes=5)
        
        merged_df['StartTime_str'] = merged_df['StartTime_dt'].dt.strftime('%H:%M')
        merged_df['EndTime_str'] = merged_df['EndTime_dt'].dt.strftime('%H:%M')
        
        return merged_df[['Hall', 'Movie', 'StartTime_str', 'EndTime_str']], date_str
    except Exception as e:
        st.error(f"Error processing the file: {e}")
        return None, date_str

def get_text_dimensions(text, font_props, fig):
    """Helper function to calculate the width and height of a text string in inches."""
    renderer = fig.canvas.get_renderer()
    t = fig.text(0, 0, text, fontproperties=font_props, visible=False)
    bbox = t.get_window_extent(renderer=renderer)
    t.remove()
    return bbox.width / fig.dpi, bbox.height / fig.dpi

def find_font_size(target_height_inches, font_path, fig, text_to_measure="Xg"):
    """Finds the font size (in points) that results in a given text height (in inches)."""
    low, high = 0, 100  # Binary search range for font size
    best_size = 10
    
    for _ in range(10):  # 10 iterations for precision
        mid = (low + high) / 2
        if mid <= 0: break
        props = font_manager.FontProperties(fname=font_path, size=mid)
        _, h = get_text_dimensions(text_to_measure, props, fig)
        if h > target_height_inches:
            high = mid
        else:
            best_size = mid
            low = mid
    return best_size

def create_print_layout(data, date_str):
    """Creates the PNG and PDF print layouts based on the new grid requirements."""
    if data is None or data.empty:
        return None

    A4_WIDTH_IN, A4_HEIGHT_IN = 8.27, 11.69
    
    # 1. Layout Calculation
    total_A = len(data) + 2  # Total rows + top/bottom margin
    row_height = A4_HEIGHT_IN / total_A
    side_margin_width = row_height  # Left/right blank columns width
    content_width = A4_WIDTH_IN - 2 * side_margin_width
    target_font_height = row_height * 0.9

    # --- Calculate font sizes and column widths ---
    dummy_fig = plt.figure()
    font_path = "simHei.ttc" if os.path.exists("simHei.ttc") else "SimHei.ttf"
    master_font_size = find_font_size(target_font_height, font_path, dummy_fig)
    master_font = get_font(size=master_font_size)

    # Prepare content to measure for max width
    data['Pinyin'] = data['Movie'].apply(get_pinyin_abbr)
    data['TimeStr'] = data['StartTime_str'] + ' - ' + data['EndTime_str']
    
    max_hall_content = max(data['Hall'].str.replace('号', ''), key=len) + "#"
    max_seq_content = f"{data.groupby('Hall').size().max()}."
    max_pinyin_content = max(data['Pinyin'], key=len) if not data['Pinyin'].empty else "PY"
    max_time_content = max(data['TimeStr'], key=len)
    
    w_hall, _ = get_text_dimensions(max_hall_content, master_font, dummy_fig)
    w_seq, _ = get_text_dimensions(max_seq_content, master_font, dummy_fig)
    w_pinyin, _ = get_text_dimensions(max_pinyin_content, master_font, dummy_fig)
    w_time, _ = get_text_dimensions(max_time_content, master_font, dummy_fig)
    plt.close(dummy_fig)

    col_width_hall = w_hall * 1.1
    col_width_seq = w_seq * 1.1
    col_width_pinyin = w_pinyin * 1.1
    col_width_time = w_time * 1.1
    
    col_width_movie = content_width - (col_width_hall + col_width_seq + col_width_pinyin + col_width_time)

    if col_width_movie <= 0:
        st.error("Content is too wide for the page. The movie title column has no space.")
        return None

    # --- Create figures for drawing ---
    output_figs = {}
    for fmt in ['png', 'pdf']:
        fig = plt.figure(figsize=(A4_WIDTH_IN, A4_HEIGHT_IN), dpi=300)
        ax = fig.add_subplot(111)
        ax.set_axis_off()
        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
        ax.set_xlim(0, A4_WIDTH_IN)
        ax.set_ylim(0, A4_HEIGHT_IN)

        # Define column x-positions (from left to right)
        x_pos = [0] * 7
        x_pos[0] = 0
        x_pos[1] = side_margin_width
        x_pos[2] = x_pos[1] + col_width_hall
        x_pos[3] = x_pos[2] + col_width_seq
        x_pos[4] = x_pos[3] + col_width_movie
        x_pos[5] = x_pos[4] + col_width_pinyin
        x_pos[6] = x_pos[5] + col_width_time

        # Add date string to the top margin area
        ax.text(A4_WIDTH_IN - side_margin_width, A4_HEIGHT_IN - (row_height / 2), date_str,
                ha='right', va='center', color='#A9A9A9', fontproperties=get_font(12))

        # --- Drawing Loop ---
        y_cursor = A4_HEIGHT_IN - row_height  # Start below top margin
        drawn_halls = set()
        
        for hall_name, group in data.groupby('Hall', sort=False):
            for i, (_, row) in enumerate(group.iterrows()):
                y_bottom = y_cursor - row_height
                y_center = y_cursor - (row_height / 2)
                
                # Draw dotted cell borders
                for c in range(5):
                    ax.add_patch(Rectangle((x_pos[c+1], y_bottom), x_pos[c+2] - x_pos[c+1], row_height,
                                           facecolor='none', edgecolor='gray', linestyle=':', linewidth=0.5))

                # Column 1: Hall Number (only on first row of the group)
                if hall_name not in drawn_halls:
                    hall_num_text = f"${row['Hall'].replace('号', '')}^{{\\#}}$"
                    ax.text(x_pos[1] + col_width_hall / 2, y_center, hall_num_text,
                            ha='center', va='center', fontproperties=master_font)
                    drawn_halls.add(hall_name)
                
                # Column 2: Sequence Number
                ax.text(x_pos[2] + col_width_seq / 2, y_center, f"{i+1}.",
                        ha='center', va='center', fontproperties=master_font)

                # Column 3: Movie Title (with font scaling)
                font_movie = master_font.copy()
                movie_cell_inner_width = col_width_movie * 0.9
                
                temp_fig = plt.figure()
                w_movie, _ = get_text_dimensions(row['Movie'], font_movie, temp_fig)
                plt.close(temp_fig)
                
                if w_movie > movie_cell_inner_width:
                    scale_factor = movie_cell_inner_width / w_movie
                    font_movie.set_size(font_movie.get_size() * scale_factor)

                ax.text(x_pos[3] + col_width_movie * 0.05, y_center, row['Movie'],
                        ha='left', va='center', fontproperties=font_movie)

                # Column 4: Pinyin Abbreviation
                ax.text(x_pos[4] + col_width_pinyin / 2, y_center, row['Pinyin'],
                        ha='center', va='center', fontproperties=master_font)
                
                # Column 5: Time
                ax.text(x_pos[5] + col_width_time / 2, y_center, row['TimeStr'],
                        ha='center', va='center', fontproperties=master_font)

                y_cursor -= row_height
            
            # Draw black separator line below each hall group
            ax.plot([x_pos[1], x_pos[6]], [y_cursor, y_cursor], color='black', linewidth=1.0)
        
        output_figs[fmt] = fig

    # --- Save figures to in-memory buffers ---
    png_buffer = io.BytesIO()
    output_figs['png'].savefig(png_buffer, format='png', bbox_inches=None, pad_inches=0)
    plt.close(output_figs['png'])
    
    pdf_buffer = io.BytesIO()
    output_figs['pdf'].savefig(pdf_buffer, format='pdf', bbox_inches=None, pad_inches=0)
    plt.close(output_figs['pdf'])
    
    # Encode for display
    png_buffer.seek(0)
    image_base64 = base64.b64encode(png_buffer.getvalue()).decode()
    pdf_buffer.seek(0)
    pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
    
    return {
        'png': f"data:image/png;base64,{image_base64}",
        'pdf': f"data:application/pdf;base64,{pdf_base64}"
    }

def display_pdf(base64_pdf):
    """Generates the HTML to embed a PDF in Streamlit."""
    return f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'

# --- Streamlit App ---
st.set_page_config(page_title="LED Screen Schedule Printing", layout="wide")
st.title("LED Screen Schedule Printing")

uploaded_file = st.file_uploader("Select the 'Screening Time Checklist.xls' file", type=["xls"])

if uploaded_file:
    with st.spinner("Processing file, please wait..."):
        schedule, date_str = process_schedule(uploaded_file)
        if schedule is not None and not schedule.empty:
            output = create_print_layout(schedule, date_str)
            if output:
                tab1, tab2 = st.tabs(["PDF Preview", "PNG Preview"])
                with tab1:
                    st.markdown(display_pdf(output['pdf']), unsafe_allow_html=True)
                with tab2:
                    st.image(output['png'], use_container_width=True)
        else:
            st.error("Could not process the file. Please check that the file format and content are correct.")