SYSTEM: You are a Python programmer tasked with refactoring code. You are proficient in Python 3.12 and use modern features where appropriate. Your code is clear, easy to read, and free of unnecessary verbosity. You follow PEP 8, 20 and 257 to ensure high quality python code. You remove comments and instead focus on simple and clear one line docstrings to describe every function. A big focus for you is reducing redundancy. You think through your task step by step. USER: import tkinter as tk
from tkinter import ttk, messagebox, font
import sqlite3
import sys

if sys.platform.startswith('win'):
    try:
        import ctypes
        ctypes.windll.shcore.SetProcessDpiAwareness(1)
    except Exception as e:
        print("Error setting DPI awareness:", e)


def run_query(query, parameters=()):
    with sqlite3.connect('media.db') as conn:
        cursor = conn.cursor()
        result = cursor.execute(query, parameters)
        if query.strip().lower().startswith("select"):
            return result.fetchall()
        conn.commit()


def create_tables():
    create_movies_table_sql = '''
    CREATE TABLE IF NOT EXISTS movies (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        movie TEXT,
        year TEXT,
        present BOOLEAN,
        watched BOOLEAN,
        notes TEXT
    );
    '''
    create_series_table_sql = '''
    CREATE TABLE IF NOT EXISTS series (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        series TEXT,
        seasons TEXT,
        year TEXT,
        present BOOLEAN,
        seasons_present TEXT,
        complete BOOLEAN,
        watched BOOLEAN,
        seasons_seen TEXT,
        notes TEXT
    );
    '''
    run_query(create_movies_table_sql)
    run_query(create_series_table_sql)


class MediaTracker(tk.Tk):
    def __init__(self):
        super().__init__()

        self.configure(bg='white')

        if sys.platform.startswith('win'):
            try:
                scaling = self.winfo_fpixels('1i') / 72
                self.tk.call('tk', 'scaling', scaling)
            except Exception as e:
                print("Error setting scaling:", e)

        self.title("Movies and Series Tracker")
        self.geometry("1200x600")

        try:
            self.custom_font = font.Font(family='Literata', size=12)
        except:
            self.custom_font = font.Font(family='Arial', size=12)

        font_line_space = self.custom_font.metrics('linespace')
        desired_padding = 4
        row_height = font_line_space + desired_padding

        style = ttk.Style()
        style.theme_use("default")

        style.layout(
            'Custom.Treeview',
            [('Custom.Treeview.treearea', {'sticky': 'nsew'})]
        )
        style.configure(
            "Custom.Treeview",
            font=self.custom_font,
            rowheight=row_height,
            borderwidth=0,
            relief='flat',
            highlightthickness=0,
            background='white',
            fieldbackground='white'
        )

        style.configure(
            "Custom.Treeview.Heading",
            font=(
                self.custom_font.cget("family"),
                self.custom_font.cget("size"),
                "bold"
            ),
            background='#F7F8FC',
            relief='solid',
            borderwidth=0,
            anchor='center'
        )
        style.map(
            "Custom.Treeview.Heading",
            background=[('active', 'white')],
            relief=[('active', 'solid')]
        )

        style.configure("Custom.TButton", font=self.custom_font)

        self.sidebar_bg = '#F7F8FC'

        self.grid_rowconfigure(1, weight=1)
        self.grid_columnconfigure(2, weight=1)

        self.header = tk.Frame(self, bg='white', height=50)
        self.header.grid(row=0, column=1, columnspan=3, sticky='ew')
        self.header.grid_propagate(False)

        self.header_label = tk.Label(
            self.header,
            text="Movies",
            bg='white',
            font=self.custom_font,
            anchor='w',
            padx=10
        )
        self.header_label.pack(fill='x', pady=10)

        self.sidebar = tk.Frame(self, width=150, bg=self.sidebar_bg)
        self.sidebar.grid(row=0, column=0, rowspan=2, sticky='ns')
        self.sidebar.grid_propagate(False)

        self.spacer = tk.Frame(self, width=60, bg='white')
        self.spacer.grid(row=1, column=1, sticky='ns')
        self.spacer.grid_propagate(False)

        self.content = tk.Frame(self, bg='white')
        self.content.grid(row=1, column=2, sticky='nsew')

        self.button_bar = tk.Frame(self, width=50, bg='white')
        self.button_bar.grid(row=1, column=3, sticky='ns')
        self.button_bar.grid_propagate(False)

        self.create_sidebar_label("Movies", self.show_movies)
        self.create_sidebar_label("Series", self.show_series)

        self.add_button = ttk.Button(
            self.button_bar,
            text="+",
            command=self.add_entry,
            width=3,
            style="Custom.TButton"
        )
        self.add_button.pack(pady=20)

        self.delete_button = ttk.Button(
            self.button_bar,
            text="-",
            command=self.delete_entry,
            width=3,
            style="Custom.TButton"
        )
        self.delete_button.pack(pady=10)

        self.tree = None
        self.scrollbar = None
        self.current_table = None
        self.current_row_id = None

        self.boolean_columns = {
            'movies': ['Present', 'Watched'],
            'series': ['Present', 'Complete', 'Watched']
        }

        self.show_movies()

    def create_sidebar_label(self, text, command):
        label = tk.Label(
            self.sidebar,
            text=text,
            bg=self.sidebar_bg,
            font=self.custom_font,
            cursor="hand2",
            anchor='w',
            padx=10,
            pady=5
        )
        label.pack(pady=10, padx=0, fill='x')
        label.bind("<Enter>", lambda e: label.config(bg='#EAEDEF'))
        label.bind("<Leave>", lambda e: label.config(bg=self.sidebar_bg))
        label.bind("<Button-1>", lambda e: command())

    def clear_content(self):
        if self.tree:
            self.tree.destroy()
            self.tree = None
        if self.scrollbar:
            self.scrollbar.destroy()
            self.scrollbar = None

    def setup_treeview(self, columns, headings):
        self.tree = ttk.Treeview(
            self.content,
            columns=columns,
            show='headings',
            selectmode='browse',
            style="Custom.Treeview"
        )
        for col, head in zip(columns, headings):
            self.tree.heading(col, text=head, anchor='center')
            if head.lower() == 'notes':
                self.tree.column(col, width=300, anchor='w')
            elif head in self.boolean_columns.get(self.current_table, []):
                self.tree.column(col, width=100, anchor='center')
            else:
                self.tree.column(col, width=150, anchor='center')

        self.scrollbar = ttk.Scrollbar(
            self.content,
            orient="vertical",
            command=self.tree.yview
        )
        self.tree.configure(yscrollcommand=self.scrollbar.set)
        self.scrollbar.pack(side='right', fill='y')
        self.tree.pack(fill='both', expand=True)

        self.tree.bind('<<TreeviewSelect>>', self.on_row_select)
        self.tree.bind('<Double-1>', self.on_double_click)
        self.tree.bind('<Button-1>', self.on_single_click)
        self.tree.bind("<Motion>", self.treeview_click_cursor)

    def treeview_click_cursor(self, event):
        region = self.tree.identify("region", event.x, event.y)
        if region == "cell":
            column = self.tree.identify_column(event.x)
            try:
                col_index = int(column.replace('#', '')) - 1
                column_name = self.tree['columns'][col_index]
                if column_name in self.boolean_columns.get(self.current_table, []):
                    self.tree.configure(cursor="hand2")
                else:
                    self.tree.configure(cursor="")
            except (IndexError, ValueError):
                self.tree.configure(cursor="")
        else:
            self.tree.configure(cursor="")

    def load_movie_data(self):
        self.clear_content()
        columns = ["Movie", "Year", "Present", "Watched", "Notes"]
        headings = ["Movie", "Year", "Present", "Watched", "Notes"]
        self.setup_treeview(columns, headings)
        self.current_table = 'movies'
        self.header_label.config(text="Movies")
        for row in run_query('SELECT * FROM movies'):
            record_id = row[0]
            movie, year, present, watched, notes = row[1], row[2], row[3], row[4], row[5]
            display_row = [
                movie,
                year,
                self.bool_to_checkbox(present),
                self.bool_to_checkbox(watched),
                notes
            ]
            self.tree.insert('', 'end', iid=str(record_id), values=display_row)

    def load_series_data(self):
        self.clear_content()
        columns = [
            "Series", "Seasons", "Year", "Present",
            "Seasons Present", "Complete", "Watched",
            "Seasons Seen", "Notes"
        ]
        headings = [
            "Series", "Seasons", "Year", "Present",
            "Seasons Present", "Complete", "Watched",
            "Seasons Seen", "Notes"
        ]
        self.setup_treeview(columns, headings)
        self.current_table = 'series'
        self.header_label.config(text="Series")
        for row in run_query('SELECT * FROM series'):
            record_id = row[0]
            (
                series, seasons, year, present, seasons_present,
                complete, watched, seasons_seen, notes
            ) = row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]
            display_row = [
                series,
                seasons,
                year,
                self.bool_to_checkbox(present),
                seasons_present,
                self.bool_to_checkbox(complete),
                self.bool_to_checkbox(watched),
                seasons_seen,
                notes
            ]
            self.tree.insert('', 'end', iid=str(record_id), values=display_row)

    def show_movies(self):
        self.load_movie_data()

    def show_series(self):
        self.load_series_data()

    def add_entry(self):
        if self.current_table == 'movies':
            run_query(
                "INSERT INTO movies (movie, year, present, watched, notes) "
                "VALUES (?, ?, ?, ?, ?)",
                ('', '', False, False, '')
            )
            self.load_movie_data()
        elif self.current_table == 'series':
            run_query(
                """INSERT INTO series
                (series, seasons, year, present, seasons_present, complete, 
                watched, seasons_seen, notes)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                ('', '', '', False, '', False, False, '', '')
            )
            self.load_series_data()

    def delete_entry(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showwarning("No selection", "Please select a row to delete.")
            return

        row_id = selected_item[0]
        if self.current_table == 'movies':
            run_query("DELETE FROM movies WHERE id = ?", (row_id,))
            self.load_movie_data()
        elif self.current_table == 'series':
            run_query("DELETE FROM series WHERE id = ?", (row_id,))
            self.load_series_data()

    def on_row_select(self, event):
        selected_item = self.tree.selection()
        if selected_item:
            self.current_row_id = selected_item[0]
        else:
            self.current_row_id = None

    def on_single_click(self, event):
        region = self.tree.identify("region", event.x, event.y)
        if region != "cell":
            return
        row_id = self.tree.identify_row(event.y)
        column = self.tree.identify_column(event.x)
        if not row_id or not column:
            return
        try:
            col_index = int(column.replace('#', '')) - 1
        except ValueError:
            return
        if col_index < 0 or col_index >= len(self.tree['columns']):
            return
        column_name = self.tree['columns'][col_index]
        if self.current_table and column_name in self.boolean_columns.get(self.current_table, []):
            current_value = self.tree.set(row_id, column_name)
            new_value = not self.checkbox_to_bool(current_value)
            self.tree.set(row_id, column_name, self.bool_to_checkbox(new_value))
            row_values = self.tree.item(row_id)['values']
            self.update_database(row_values)

    def on_double_click(self, event):
        item = self.tree.identify_row(event.y)
        column = self.tree.identify_column(event.x)
        if not item:
            return
        try:
            col_num = int(column.replace('#', '')) - 1
        except ValueError:
            return
        if (
            (self.current_table == 'movies' and
             self.tree['columns'][col_num] in self.boolean_columns['movies']) or
            (self.current_table == 'series' and
             self.tree['columns'][col_num] in self.boolean_columns['series'])
        ):
            return
        if col_num < 0 or col_num >= len(self.tree['columns']):
            return
        column_name = self.tree['columns'][col_num]
        value = self.tree.set(item, column_name)
        if self.current_table and column_name in self.boolean_columns.get(self.current_table, []):
            return
        bbox = self.tree.bbox(item, column)
        if not bbox:
            return
        x, y, width, height = bbox
        entry = tk.Entry(
            self.content,
            font=self.custom_font,
            relief='flat',
            borderwidth=0,
            highlightthickness=0,
            bg='white'
        )
        entry.place(x=x, y=y, width=width, height=height)
        entry.insert(0, value)
        entry.focus()

        def save_edit(event_inner):
            new_value = entry.get()
            entry.destroy()
            self.tree.set(item, column_name, new_value)
            row_values = self.tree.item(item)['values']
            self.update_database(row_values)

        entry.bind('<Return>', save_edit)
        entry.bind('<FocusOut>', save_edit)

    def update_database(self, row_values):
        if self.current_table == 'movies':
            present = self.checkbox_to_bool(row_values[2])
            watched = self.checkbox_to_bool(row_values[3])
            query = (
                "UPDATE movies SET movie = ?, year = ?, present = ?, "
                "watched = ?, notes = ? WHERE id = ?"
            )
            parameters = (
                row_values[0], row_values[1], present, watched,
                row_values[4], self.current_row_id
            )
        elif self.current_table == 'series':
            present = self.checkbox_to_bool(row_values[3])
            complete = self.checkbox_to_bool(row_values[5])
            watched = self.checkbox_to_bool(row_values[6])
            query = (
                """UPDATE series SET series = ?, seasons = ?, year = ?, present = ?,
                seasons_present = ?, complete = ?, watched = ?, seasons_seen = ?,
                notes = ? WHERE id = ?"""
            )
            parameters = (
                row_values[0], row_values[1], row_values[2],
                present, row_values[4],
                complete, watched,
                row_values[7], row_values[8], self.current_row_id
            )
        run_query(query, parameters)

    @staticmethod
    def bool_to_checkbox(value):
        return '☑' if value else '☐'

    @staticmethod
    def checkbox_to_bool(value):
        return True if value == '☑' else False


if __name__ == "__main__":
    create_tables()
    app = MediaTracker()
    app.mainloop()