app.py

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

# --- Constants for the second script ---
SPLIT_TIME = "17:30"
BUSINESS_START = "09:30"
BUSINESS_END = "01:30"
BORDER_COLOR = 'grey'
DATE_COLOR = '#A9A9A9'
A5_WIDTH_IN = 5.83
A5_HEIGHT_IN = 8.27
NUM_COLS = 3

# --- Functions from the first script ---
def get_font(size=14):
    """Loads a specific TrueType font, defaulting to a common Chinese font."""
    font_path = "simHei.ttc"
    if not os.path.exists(font_path):
        font_path = "SimHei.ttf"
    if os.path.exists(font_path):
        return font_manager.FontProperties(fname=font_path, size=size)
    else:
        st.warning("SimHei font not found. Display may not be correct. Please add simHei.ttc or SimHei.ttf.")
        return font_manager.FontProperties(family='sans-serif', size=size)

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

def format_seq(n):
    """Converts an integer to a circled number string (e.g., 1 -> ①)."""
    if not isinstance(n, int) or n <= 0:
        return str(n)
    circled_chars = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳" \
                    "㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟" \
                    "㊱㊲㊳㊴㊵㊶㊷㊸㊹㊺㊻㊼㊽㊾㊿"
    if 1 <= n <= 50:
        return circled_chars[n - 1]
    return f'({n})'

def process_schedule_led(file):
    """Processes '放映时间核对表.xls'."""
    try:
        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:
        date_str = datetime.today().strftime('%Y-%m-%d')
        base_date = datetime.today().date()

    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['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
        )
        df.loc[df['EndTime_dt'] < df['StartTime_dt'], 'EndTime_dt'] += timedelta(days=1)
        df = df.sort_values(['Hall', 'StartTime_dt'])
        merged_rows = []
        for _, 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)
        merged_df = pd.DataFrame(merged_rows)
        merged_df['StartTime_dt'] -= timedelta(minutes=10)
        merged_df['EndTime_dt'] -= timedelta(minutes=5)
        merged_df['Seq'] = merged_df.groupby('Hall').cumcount() + 1
        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', 'Seq', 'Movie', 'StartTime_str', 'EndTime_str']], date_str
    except Exception as e:
        st.error(f"Error processing schedule data: {e}. Please check the file format.")
        return None, date_str

def create_print_layout_led(data, date_str):
    """Generates print layouts for '放映时间核对表.xls'."""
    if data is None or data.empty:
        return None
    A4_width_in, A4_height_in = 8.27, 11.69
    dpi = 300
    total_content_rows = len(data)
    totalA = total_content_rows + 2
    row_height = A4_height_in / totalA
    data = data.reset_index(drop=True)
    data['hall_str'] = '$' + data['Hall'].str.replace('号', '') + '^{\#}$'
    data['seq_str'] = data['Seq'].apply(format_seq)
    data['pinyin_abbr'] = data['Movie'].apply(get_pinyin_abbr)
    data['time_str'] = data['StartTime_str'] + ' - ' + data['EndTime_str']
    temp_fig = plt.figure(figsize=(A4_width_in, A4_height_in), dpi=dpi)
    renderer = temp_fig.canvas.get_renderer()
    base_font_size_pt = (row_height * 0.9) * 72
    seq_font_size_pt = (row_height * 0.5) * 72

    def get_col_width_in(series, font_size_pt, is_math=False):
        if series.empty:
            return 0
        font_prop = get_font(font_size_pt)
        longest_str_idx = series.astype(str).str.len().idxmax()
        max_content = str(series.loc[longest_str_idx])
        text_width_px, _, _ = renderer.get_text_width_height_descent(max_content, font_prop, ismath=is_math)
        return (text_width_px / dpi) * 1.1

    margin_col_width = row_height
    hall_col_width = get_col_width_in(data['hall_str'], base_font_size_pt, is_math=True)
    seq_col_width = get_col_width_in(data['seq_str'], seq_font_size_pt)
    pinyin_col_width = get_col_width_in(data['pinyin_abbr'], base_font_size_pt)
    time_col_width = get_col_width_in(data['time_str'], base_font_size_pt)
    movie_col_width = A4_width_in - (
            margin_col_width * 2 + hall_col_width + seq_col_width + pinyin_col_width + time_col_width)
    plt.close(temp_fig)
    col_widths = {'hall': hall_col_width, 'seq': seq_col_width, 'movie': movie_col_width, 'pinyin': pinyin_col_width,
                  'time': time_col_width}
    col_x_starts = {}
    current_x = margin_col_width
    for col_name in ['hall', 'seq', 'movie', 'pinyin', 'time']:
        col_x_starts[col_name] = current_x
        current_x += col_widths[col_name]

    def draw_figure(fig, ax):
        renderer = fig.canvas.get_renderer()
        for col_name in ['hall', 'seq', 'movie', 'pinyin']:
            x_line = col_x_starts[col_name] + col_widths[col_name]
            line_top_y, line_bottom_y = A4_height_in - row_height, row_height
            ax.add_line(
                Line2D([x_line, x_line], [line_bottom_y, line_top_y], color='gray', linestyle=':', linewidth=0.5))
        last_hall_drawn = None
        for i, row in data.iterrows():
            y_bottom = A4_height_in - (i + 2) * row_height
            y_center = y_bottom + row_height / 2
            if row['Hall'] != last_hall_drawn:
                ax.text(col_x_starts['hall'] + col_widths['hall'] / 2, y_center, row['hall_str'],
                        fontproperties=get_font(base_font_size_pt), ha='center', va='center')
                last_hall_drawn = row['Hall']
            ax.text(col_x_starts['seq'] + col_widths['seq'] / 2, y_center, row['seq_str'],
                    fontproperties=get_font(seq_font_size_pt), ha='center', va='center')
            ax.text(col_x_starts['pinyin'] + col_widths['pinyin'] / 2, y_center, row['pinyin_abbr'],
                    fontproperties=get_font(base_font_size_pt), ha='center', va='center')
            ax.text(col_x_starts['time'] + col_widths['time'] / 2, y_center, row['time_str'],
                    fontproperties=get_font(base_font_size_pt), ha='center', va='center')
            movie_font_size = base_font_size_pt
            movie_font_prop = get_font(movie_font_size)
            text_w_px, _, _ = renderer.get_text_width_height_descent(row['Movie'], movie_font_prop, ismath=False)
            text_w_in = text_w_px / dpi
            max_width_in = col_widths['movie'] * 0.9
            if text_w_in > max_width_in:
                movie_font_size *= (max_width_in / text_w_in)
                movie_font_prop = get_font(movie_font_size)
            ax.text(col_x_starts['movie'] + 0.05, y_center, row['Movie'],
                    fontproperties=movie_font_prop, ha='left', va='center')
            is_last_in_hall = (i == len(data) - 1) or (row['Hall'] != data.loc[i + 1, 'Hall'])
            line_start_x = margin_col_width
            line_end_x = A4_width_in - margin_col_width
            if is_last_in_hall:
                ax.add_line(Line2D([line_start_x, line_end_x], [y_bottom, y_bottom], color='black', linestyle='-',
                                   linewidth=0.8))
            else:
                ax.add_line(Line2D([line_start_x, line_end_x], [y_bottom, y_bottom], color='gray', linestyle=':',
                                   linewidth=0.5))

    outputs = {}
    for format_type in ['png', 'pdf']:
        fig = plt.figure(figsize=(A4_width_in, A4_height_in), dpi=dpi)
        ax = fig.add_axes([0, 0, 1, 1])
        ax.set_axis_off()
        ax.set_xlim(0, A4_width_in)
        ax.set_ylim(0, A4_height_in)
        ax.text(margin_col_width, A4_height_in - (row_height / 2), date_str,
                fontproperties=get_font(10), color='#A9A9A9', ha='left', va='center')
        draw_figure(fig, ax)
        buf = io.BytesIO()
        fig.savefig(buf, format=format_type, dpi=dpi, bbox_inches='tight', pad_inches=0)
        buf.seek(0)
        data_uri = base64.b64encode(buf.getvalue()).decode()
        mime_type = 'image/png' if format_type == 'png' else 'application/pdf'
        outputs[format_type] = f"data:{mime_type};base64,{data_uri}"
        plt.close(fig)
    return outputs

# --- Functions from the second script ---
def process_schedule_times(file):
    """Processes '放映场次核对表.xls'."""
    try:
        df = pd.read_excel(file, skiprows=8)
        df = df.iloc[:, [6, 7, 9]]
        df.columns = ['Hall', 'StartTime', 'EndTime']
        df = df.dropna(subset=['Hall', 'StartTime', 'EndTime'])
        df['Hall'] = df['Hall'].str.extract(r'(\d+)号').astype(str) + ' '
        df['original_end'] = df['EndTime']
        base_date = datetime.today().date()
        df['StartTime'] = pd.to_datetime(df['StartTime'])
        df['EndTime'] = pd.to_datetime(df['EndTime'])
        business_start = datetime.strptime(f"{base_date} {BUSINESS_START}", "%Y-%m-%d %H:%M")
        business_end = datetime.strptime(f"{base_date} {BUSINESS_END}", "%Y-%m-%d %H:%M")
        if business_end < business_start:
            business_end += timedelta(days=1)
        for idx, row in df.iterrows():
            end_time = row['EndTime']
            if end_time.hour < 9:
                df.at[idx, 'EndTime'] = end_time + timedelta(days=1)
            if row['StartTime'].hour >= 21 and end_time.hour < 9:
                df.at[idx, 'EndTime'] = end_time + timedelta(days=1)
        df['time_for_comparison'] = df['EndTime'].apply(
            lambda x: datetime.combine(base_date, x.time())
        )
        df.loc[df['time_for_comparison'].dt.hour < 9, 'time_for_comparison'] += timedelta(days=1)
        valid_times = (
                ((df['time_for_comparison'] >= datetime.combine(base_date, business_start.time())) &
                 (df['time_for_comparison'] <= datetime.combine(base_date + timedelta(days=1), business_end.time())))
        )
        df = df[valid_times]
        df = df.sort_values('EndTime')
        split_time = datetime.strptime(f"{base_date} {SPLIT_TIME}", "%Y-%m-%d %H:%M")
        split_time_for_comparison = df['time_for_comparison'].apply(
            lambda x: datetime.combine(base_date, split_time.time())
        )
        part1 = df[df['time_for_comparison'] <= split_time_for_comparison].copy()
        part2 = df[df['time_for_comparison'] > split_time_for_comparison].copy()
        for part in [part1, part2]:
            part['EndTime'] = part['EndTime'].dt.strftime('%-H:%M')
        date_df = pd.read_excel(
            file,
            skiprows=5,
            nrows=1,
            usecols=[2],
            header=None
        )
        date_cell = date_df.iloc[0, 0]
        try:
            if isinstance(date_cell, str):
                date_str = datetime.strptime(date_cell, '%Y-%m-%d').strftime('%Y-%m-%d')
            else:
                date_str = pd.to_datetime(date_cell).strftime('%Y-%m-%d')
        except:
            date_str = datetime.today().strftime('%Y-%m-%d')
        return part1[['Hall', 'EndTime']], part2[['Hall', 'EndTime']], date_str
    except Exception as e:
        st.error(f"处理文件时出错: {str(e)}")
        return None, None, None

def create_print_layout_times(data, title, date_str):
    """Creates print layouts for '放映场次核对表.xls'."""
    if data.empty:
        return None

    def generate_figure():
        total_items = len(data)
        num_rows = math.ceil(total_items / NUM_COLS) if total_items > 0 else 1
        date_header_height_in = 0.3
        data_area_height_in = A5_HEIGHT_IN - date_header_height_in
        cell_width_in = A5_WIDTH_IN / NUM_COLS
        cell_height_in = data_area_height_in / num_rows
        cell_width_pt = cell_width_in * 72
        cell_height_pt = cell_height_in * 72
        target_text_width_pt = cell_width_pt * 0.9
        fontsize_from_width = target_text_width_pt / (8 * 0.6)
        fontsize_from_height = cell_height_pt * 0.8
        base_fontsize = min(fontsize_from_width, fontsize_from_height)
        fig = plt.figure(figsize=(A5_WIDTH_IN, A5_HEIGHT_IN), dpi=300)
        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
        plt.rcParams['font.family'] = 'sans-serif'
        plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
        gs = gridspec.GridSpec(
            num_rows + 1, NUM_COLS,
            hspace=0, wspace=0,
            height_ratios=[date_header_height_in] + [cell_height_in] * num_rows,
            figure=fig
        )
        data_values = data.values.tolist()
        while len(data_values) % NUM_COLS != 0:
            data_values.append(['', ''])
        rows_per_col_layout = math.ceil(len(data_values) / NUM_COLS)
        sorted_data = [['', '']] * len(data_values)
        for i, item in enumerate(data_values):
            if item[0] and item[1]:
                row_in_col = i % rows_per_col_layout
                col_idx = i // rows_per_col_layout
                new_index = row_in_col * NUM_COLS + col_idx
                if new_index < len(sorted_data):
                    sorted_data[new_index] = item
        for idx, (hall, end_time) in enumerate(sorted_data):
            if hall and end_time:
                row_grid = idx // NUM_COLS + 1
                col_grid = idx % NUM_COLS
                ax = fig.add_subplot(gs[row_grid, col_grid])
                for spine in ax.spines.values():
                    spine.set_visible(True)
                    spine.set_linestyle((0, (1, 2)))
                    spine.set_color(BORDER_COLOR)
                    spine.set_linewidth(0.75)
                display_text = f"{hall}{end_time}"
                ax.text(0.5, 0.5, display_text,
                        fontsize=base_fontsize,
                        fontweight='bold',
                        ha='center', va='center',
                        transform=ax.transAxes)
                ax.set_xticks([])
                ax.set_yticks([])
                ax.set_facecolor('none')
        ax_date = fig.add_subplot(gs[0, :])
        ax_date.text(0.01, 0.5, f"{date_str} {title}",
                     fontsize=base_fontsize * 0.5,
                     color=DATE_COLOR, fontweight='bold',
                     ha='left', va='center',
                     transform=ax_date.transAxes)
        ax_date.set_axis_off()
        ax_date.set_facecolor('none')
        return fig

    fig_for_output = generate_figure()
    png_buffer = io.BytesIO()
    fig_for_output.savefig(png_buffer, format='png')
    png_buffer.seek(0)
    png_base64 = base64.b64encode(png_buffer.getvalue()).decode()
    pdf_buffer = io.BytesIO()
    with PdfPages(pdf_buffer) as pdf:
        pdf.savefig(fig_for_output)
    pdf_buffer.seek(0)
    pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
    plt.close(fig_for_output)
    return {
        'png': f'data:image/png;base64,{png_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="Schedule Printer", layout="wide")
st.title("Schedule Printer")

uploaded_file = st.file_uploader("Select '放映时间核对表.xls' or '放映场次核对表.xls'",
                                 type=["xls", "xlsx"])

if uploaded_file:
    if "时间" in uploaded_file.name:
        st.header("LED Screen Schedule")
        with st.spinner("Processing file, please wait..."):
            schedule, date_str = process_schedule_led(uploaded_file)
            if schedule is not None and not schedule.empty:
                output = create_print_layout_led(schedule, date_str)
                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 if the file format and content are correct.")
    elif "场次" in uploaded_file.name:
        st.header("Screening Times Quick Print")
        part1, part2, date_str = process_schedule_times(uploaded_file)
        if part1 is not None and part2 is not None:
            part1_output = create_print_layout_times(part1, "A", date_str)
            part2_output = create_print_layout_times(part2, "C", date_str)
            col1, col2 = st.columns(2)
            with col1:
                st.subheader("Day Shift (End time <= 17:30)")
                if part1_output:
                    tab1_1, tab1_2 = st.tabs(["PDF Preview", "PNG Preview"])
                    with tab1_1:
                        st.markdown(display_pdf(part1_output['pdf']), unsafe_allow_html=True)
                    with tab1_2:
                        st.image(part1_output['png'])
                else:
                    st.info("No data for the day shift.")
            with col2:
                st.subheader("Night Shift (End time > 17:30)")
                if part2_output:
                    tab2_1, tab2_2 = st.tabs(["PDF Preview", "PNG Preview"])
                    with tab2_1:
                        st.markdown(display_pdf(part2_output['pdf']), unsafe_allow_html=True)
                    with tab2_2:
                        st.image(part2_output['png'])
                else:
                    st.info("No data for the night shift.")