modern_gui_main.py

import sqlite3
import customtkinter as ctk
from tkinter import ttk, messagebox, simpledialog, filedialog
from datetime import datetime, timedelta
import os
import shutil
import platform
import subprocess
import urllib.parse
import webbrowser
import json
from PIL import Image, ImageTk 
from fpdf import FPDF, XPos, YPos

# Try importing matplotlib for graphs
try:
    import matplotlib.pyplot as plt
    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
    HAS_MATPLOTLIB = True
except ImportError:
    HAS_MATPLOTLIB = False

# --- GLOBAL SETTINGS ---
ctk.set_appearance_mode("System")
ctk.set_default_color_theme("blue")
ctk.set_widget_scaling(1.2) 

# --- FILE SYSTEM SETUP ---
UPLOAD_DIR = os.path.abspath("goat_uploads")
if not os.path.exists(UPLOAD_DIR):
    os.makedirs(UPLOAD_DIR)

REPORTS_DIR = os.path.abspath("goat_reports")
if not os.path.exists(REPORTS_DIR):
    os.makedirs(REPORTS_DIR)

# ==========================================
# 1. THE BACKEND
# ==========================================
class Database:
    def __init__(self, db_file="goat_herd.db"):
        self.db_file = db_file
        self.init_db()

    def get_connection(self):
        conn = sqlite3.connect(self.db_file)
        conn.row_factory = sqlite3.Row
        return conn

    def init_db(self):
        conn = self.get_connection()
        try:
            # 1. MIGRATIONS (Add columns if missing)
            try: 
                conn.execute("ALTER TABLE health_events ADD COLUMN performed_by TEXT")
            except: 
                pass 
            
            try: 
                conn.execute("ALTER TABLE health_events ADD COLUMN image_path TEXT")
            except: 
                pass
            
            try: 
                conn.execute("ALTER TABLE goats ADD COLUMN profile_image TEXT")
            except: 
                pass 

            # 2. CREATE TABLES IF THEY DON'T EXIST
            conn.execute('''CREATE TABLE IF NOT EXISTS goats (
                            id INTEGER PRIMARY KEY AUTOINCREMENT,
                            tag_number TEXT,
                            name TEXT,
                            breed TEXT,
                            sex TEXT,
                            date_of_birth TEXT,
                            sire_id INTEGER,
                            dam_id INTEGER,
                            source TEXT,
                            purchase_price REAL,
                            registration_number TEXT,
                            is_active INTEGER DEFAULT 1,
                            archive_reason TEXT,
                            archive_date TEXT,
                            final_weight REAL,
                            archive_notes TEXT,
                            profile_image TEXT
                        )''')
            
            conn.execute('''CREATE TABLE IF NOT EXISTS health_events (
                            id INTEGER PRIMARY KEY AUTOINCREMENT,
                            goat_id INTEGER,
                            event_date TEXT,
                            event_type TEXT,
                            weight_recorded REAL,
                            dosage TEXT,
                            cost REAL,
                            details TEXT,
                            treatment_number INTEGER,
                            total_treatments_needed INTEGER,
                            follow_up_date TEXT,
                            performed_by TEXT,
                            image_path TEXT,
                            FOREIGN KEY(goat_id) REFERENCES goats(id)
                        )''')

            conn.execute('''CREATE TABLE IF NOT EXISTS breeding_records (
                            id INTEGER PRIMARY KEY AUTOINCREMENT,
                            doe_id INTEGER,
                            buck_id INTEGER,
                            breeding_date TEXT,
                            expected_due_date TEXT,
                            pregnancy_confirmed INTEGER DEFAULT 0,
                            scan_confirmed INTEGER DEFAULT 0,
                            kidding_date TEXT,
                            kids_count INTEGER,
                            FOREIGN KEY(doe_id) REFERENCES goats(id),
                            FOREIGN KEY(buck_id) REFERENCES goats(id)
                        )''')

            conn.execute("""
                CREATE TABLE IF NOT EXISTS documents (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    goat_id INTEGER,
                    file_path TEXT,
                    doc_type TEXT,
                    notes TEXT,
                    upload_date TEXT,
                    FOREIGN KEY(goat_id) REFERENCES goats(id)
                )
            """)
            
            conn.commit()
        except Exception as e: print(f"DB Init Warning: {e}")
        finally: conn.close()

    # --- FETCH METHODS ---
    def fetch_active_goats(self, sex_filter=None):
        conn = self.get_connection()
        cursor = conn.cursor()
        sql = "SELECT id, tag_number, name, breed, sex, date_of_birth, source, purchase_price, profile_image FROM goats WHERE is_active = 1"
        args = []
        if sex_filter:
            sql += " AND sex = ?"
            args.append(sex_filter)
        sql += " ORDER BY name"
        cursor.execute(sql, args)
        rows = cursor.fetchall()
        conn.close()
        return rows

    def fetch_archived_goats(self):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT id, tag_number, name, breed, sex, archive_reason, archive_date FROM goats WHERE is_active = 0 ORDER BY archive_date DESC")
        rows = cursor.fetchall()
        conn.close()
        return rows

    def fetch_health_history(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM health_events WHERE goat_id = ? ORDER BY event_date DESC", (goat_id,))
        rows = cursor.fetchall()
        conn.close()
        return rows
    
    def fetch_weight_data(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT event_date, weight_recorded FROM health_events WHERE goat_id=? AND weight_recorded > 0 ORDER BY event_date ASC", (goat_id,))
        rows = cursor.fetchall()
        conn.close()
        return rows

    def fetch_health_event_by_id(self, event_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM health_events WHERE id=?", (event_id,))
        return cursor.fetchone()

    def fetch_breeding_records(self):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("""
            SELECT b.id, d.name as doe, s.name as buck, b.breeding_date, b.expected_due_date, 
                   b.pregnancy_confirmed, b.scan_confirmed, b.kidding_date, b.kids_count, b.doe_id, b.buck_id
            FROM breeding_records b
            LEFT JOIN goats d ON b.doe_id = d.id
            LEFT JOIN goats s ON b.buck_id = s.id
            ORDER BY b.expected_due_date ASC
        """)
        rows = cursor.fetchall()
        conn.close()
        return rows
    
    def fetch_breeding_record_by_id(self, rec_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM breeding_records WHERE id=?", (rec_id,))
        return cursor.fetchone()

    def fetch_alerts_data(self):
        conn = self.get_connection()
        cursor = conn.cursor()
        
        cursor.execute("""
            SELECT h.follow_up_date, h.event_type, h.treatment_number, g.name, g.tag_number, g.id as goat_id, h.id as event_id
            FROM health_events h JOIN goats g ON h.goat_id = g.id 
            WHERE h.follow_up_date IS NOT NULL AND h.follow_up_date != ''
        """)
        health = cursor.fetchall()
        
        cursor.execute("""
            SELECT b.id as record_id, b.breeding_date, b.pregnancy_confirmed, b.scan_confirmed, b.expected_due_date, d.name, d.tag_number, d.id as goat_id
            FROM breeding_records b JOIN goats d ON b.doe_id = d.id 
            WHERE b.kidding_date IS NULL
        """)
        breeding = cursor.fetchall()
        conn.close()
        return health, breeding

    def fetch_all_health_events(self):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT h.event_date, h.event_type, h.weight_recorded, h.cost, h.details, h.performed_by, g.name FROM health_events h JOIN goats g ON h.goat_id = g.id ORDER BY h.event_date DESC")
        rows = cursor.fetchall()
        conn.close()
        return rows
        
    def fetch_goat_details(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT g.*, d.name as dam_name, s.name as sire_name, d.tag_number as dam_tag, s.tag_number as sire_tag FROM goats g LEFT JOIN goats d ON g.dam_id=d.id LEFT JOIN goats s ON g.sire_id=s.id WHERE g.id=?", (goat_id,))
        return cursor.fetchone()
    
    def fetch_goat_offspring(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT id, name, tag_number, sex, date_of_birth FROM goats WHERE dam_id = ? OR sire_id = ? ORDER BY date_of_birth ASC", (goat_id, goat_id))
        rows = cursor.fetchall()
        conn.close()
        return rows

    def fetch_goat_by_id(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM goats WHERE id=?", (goat_id,))
        return cursor.fetchone()

    def fetch_pedigree_tree(self, goat_id):
        def get_g(gid):
            if not gid: return None
            return self.fetch_goat_details(gid)
        me = get_g(goat_id)
        if not me: return None
        tree = { "me": me, "sire": get_g(me['sire_id']), "dam": get_g(me['dam_id']), "ss": None, "sd": None, "ds": None, "dd": None }
        if tree['sire']:
            tree['ss'] = get_g(tree['sire']['sire_id'])
            tree['sd'] = get_g(tree['sire']['dam_id'])
        if tree['dam']:
            tree['ds'] = get_g(tree['dam']['sire_id'])
            tree['dd'] = get_g(tree['dam']['dam_id'])
        return tree

    def fetch_full_breeding_history(self, goat_id, sex):
        conn = self.get_connection()
        cursor = conn.cursor()
        if sex in ['Doe', 'Doeling']:
            sql = """SELECT b.*, s.name as partner_name, s.tag_number as partner_tag FROM breeding_records b LEFT JOIN goats s ON b.buck_id = s.id WHERE b.doe_id = ? ORDER BY b.breeding_date DESC"""
        else:
            sql = """SELECT b.*, d.name as partner_name, d.tag_number as partner_tag FROM breeding_records b LEFT JOIN goats d ON b.doe_id = d.id WHERE b.buck_id = ? ORDER BY b.breeding_date DESC"""
        cursor.execute(sql, (goat_id,))
        rows = cursor.fetchall()
        conn.close()
        return rows

    # --- DOCUMENTS ---
    def add_document(self, goat_id, file_path, doc_type, notes):
        conn = self.get_connection()
        try:
            dt = datetime.now().strftime("%Y-%m-%d")
            conn.execute("INSERT INTO documents (goat_id, file_path, doc_type, notes, upload_date) VALUES (?, ?, ?, ?, ?)", 
                         (goat_id, file_path, doc_type, notes, dt))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def fetch_documents(self, goat_id):
        conn = self.get_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM documents WHERE goat_id=? ORDER BY upload_date DESC", (goat_id,))
        rows = cursor.fetchall()
        conn.close()
        return rows

    def delete_document(self, doc_id):
        conn = self.get_connection()
        try:
            conn.execute("DELETE FROM documents WHERE id=?", (doc_id,))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    # --- CRUD ---
    def add_goat(self, name, tag, reg, breed, dob, sex, sire_id=None, dam_id=None, source="Farm Born", price=0, profile_image=None):
        conn = self.get_connection()
        try:
            conn.execute("INSERT INTO goats (name, tag_number, registration_number, breed, date_of_birth, sex, sire_id, dam_id, source, purchase_price, profile_image) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", (name, tag, reg, breed, dob, sex, sire_id, dam_id, source, price, profile_image))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def add_health_event(self, goat_id, date, etype, weight, dosage, cost, details, admin, t_num=1, t_total=1, follow_up=None, img_path=None):
        conn = self.get_connection()
        try:
            conn.execute("INSERT INTO health_events (goat_id, event_date, event_type, weight_recorded, dosage, cost, details, performed_by, treatment_number, total_treatments_needed, follow_up_date, image_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", (goat_id, date, etype, weight, dosage, cost, details, admin, t_num, t_total, follow_up, img_path))
            conn.commit()
            return True
        except Exception as e: 
            print(f"DB Error: {e}")
            return False
        finally: conn.close()

    def add_breeding(self, doe_id, buck_id, date, due):
        conn = self.get_connection()
        try:
            conn.execute("INSERT INTO breeding_records (doe_id, buck_id, breeding_date, expected_due_date) VALUES (?, ?, ?, ?)", (doe_id, buck_id, date, due))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def update_goat(self, goat_id, name, tag, reg, breed, dob, sex, sire_id, dam_id, profile_image=None):
        conn = self.get_connection()
        try:
            if profile_image:
                conn.execute("UPDATE goats SET name=?, tag_number=?, registration_number=?, breed=?, date_of_birth=?, sex=?, sire_id=?, dam_id=?, profile_image=? WHERE id=?", (name, tag, reg, breed, dob, sex, sire_id, dam_id, profile_image, goat_id))
            else:
                conn.execute("UPDATE goats SET name=?, tag_number=?, registration_number=?, breed=?, date_of_birth=?, sex=?, sire_id=?, dam_id=? WHERE id=?", (name, tag, reg, breed, dob, sex, sire_id, dam_id, goat_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()
    
    def update_goat_photo(self, goat_id, path):
        conn = self.get_connection()
        try:
            conn.execute("UPDATE goats SET profile_image=? WHERE id=?", (path, goat_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def update_health_event(self, event_id, date, etype, weight, dosage, cost, details, admin, img_path=None):
        conn = self.get_connection()
        try:
            if img_path:
                 conn.execute("UPDATE health_events SET event_date=?, event_type=?, weight_recorded=?, dosage=?, cost=?, details=?, performed_by=?, image_path=? WHERE id=?", (date, etype, weight, dosage, cost, details, admin, img_path, event_id))
            else:
                 conn.execute("UPDATE health_events SET event_date=?, event_type=?, weight_recorded=?, dosage=?, cost=?, details=?, performed_by=? WHERE id=?", (date, etype, weight, dosage, cost, details, admin, event_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def archive_goat(self, goat_id, reason, date, weight, notes):
        conn = self.get_connection()
        try:
            conn.execute("UPDATE goats SET is_active=0, archive_reason=?, archive_date=?, final_weight=?, archive_notes=? WHERE id=?", (reason, date, weight, notes, goat_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()
    
    def restore_goat(self, goat_id):
        conn = self.get_connection()
        try:
            conn.execute("UPDATE goats SET is_active=1, archive_reason=NULL, archive_date=NULL, final_weight=NULL, archive_notes=NULL WHERE id=?", (goat_id,))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def delete_health_event(self, event_id):
        conn = self.get_connection()
        try:
            conn.execute("DELETE FROM health_events WHERE id=?", (event_id,))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def delete_breeding_record(self, rec_id):
        conn = self.get_connection()
        try:
            conn.execute("DELETE FROM breeding_records WHERE id=?", (rec_id,))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def update_breeding_status(self, rec_id, confirmed, scanned):
        conn = self.get_connection()
        try:
            conn.execute("UPDATE breeding_records SET pregnancy_confirmed=?, scan_confirmed=? WHERE id=?", (confirmed, scanned, rec_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    def update_kidding(self, rec_id, date, count):
        conn = self.get_connection()
        try:
            count_int = int(count)
            conn.execute("UPDATE breeding_records SET kidding_date=?, kids_count=? WHERE id=?", (date, count_int, rec_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()
        
    def update_breeding_record(self, rec_id, doe_id, buck_id, date, due):
        conn = self.get_connection()
        try:
            conn.execute("UPDATE breeding_records SET doe_id=?, buck_id=?, breeding_date=?, expected_due_date=? WHERE id=?", (doe_id, buck_id, date, due, rec_id))
            conn.commit()
            return True
        except: return False
        finally: conn.close()

    # --- CONFIG / BACKUP ---
    def create_backup(self):
        try:
            if not os.path.exists("backups"): os.makedirs("backups")
            ts = datetime.now().strftime("%Y%m%d_%H%M%S")
            dest = f"backups/backup_{ts}.db"
            shutil.copy2(self.db_file, dest)
            return dest
        except: return None
    
    def restore_backup(self, backup_path):
        try:
            shutil.copy2(backup_path, self.db_file)
            return True
        except: return False

    def save_email_config(self, email):
        with open("config.json", "w") as f: json.dump({"email": email}, f)

    def load_email_config(self):
        try:
            with open("config.json", "r") as f: return json.load(f).get("email", "")
        except: return ""

# ==========================================
# 2. THE FRONTEND
# ==========================================
class ModernGoatGUI(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.db = Database()
        self.title("Goat Manager 47.1")
        self.geometry("1300x850")

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

        self.sidebar = ctk.CTkFrame(self, width=200, corner_radius=0)
        self.sidebar.grid(row=0, column=0, sticky="nsew")
        self.sidebar.grid_rowconfigure(6, weight=1)

        self.logo_label = ctk.CTkLabel(self.sidebar, text="GOAT MANAGER", font=ctk.CTkFont(size=22, weight="bold"))
        self.logo_label.grid(row=0, column=0, padx=20, pady=(20, 10))

        self.btn_dash = self.create_nav_btn("Dashboard", 1, self.show_dashboard, "gray")
        self.btn_herd = self.create_nav_btn("Active Herd", 2, self.show_herd, "#2cc985") 
        self.btn_health = self.create_nav_btn("Health Log", 3, self.show_health, "#ff6b6b") 
        self.btn_breed = self.create_nav_btn("Breeding", 4, self.show_breeding, "#4dabf7") 
        self.btn_report = self.create_nav_btn("Reports", 5, self.show_reports, "gray")

        self.appearance_mode_label = ctk.CTkLabel(self.sidebar, text="Appearance Mode:", anchor="w")
        self.appearance_mode_label.grid(row=8, column=0, padx=20, pady=(10, 0))
        self.appearance_mode_optionemenu = ctk.CTkOptionMenu(self.sidebar, values=["System", "Dark", "Light"], command=self.change_appearance_mode_event)
        self.appearance_mode_optionemenu.grid(row=9, column=0, padx=20, pady=(10, 20))

        self.main_frame = ctk.CTkFrame(self, corner_radius=0, fg_color="transparent")
        self.main_frame.grid(row=0, column=1, sticky="nsew", padx=20, pady=20)
        
        self.tabview = ctk.CTkTabview(self.main_frame, width=1100, height=750)
        self.tabview.pack(fill="both", expand=True)
        self.tabview.add("Dashboard")
        self.tabview.add("Herd")
        self.tabview.add("Health")
        self.tabview.add("Breeding")
        self.tabview.add("Reports")
        
        self.frames = {}
        self.frames["Dashboard"] = DashboardFrame(self.tabview.tab("Dashboard"), self)
        self.frames["Herd"] = HerdFrame(self.tabview.tab("Herd"), self)
        self.frames["Health"] = HealthFrame(self.tabview.tab("Health"), self)
        self.frames["Breeding"] = BreedingFrame(self.tabview.tab("Breeding"), self)
        self.frames["Reports"] = ReportsFrame(self.tabview.tab("Reports"), self)

        for frame in self.frames.values(): frame.pack(fill="both", expand=True)
        self.show_dashboard()

    def create_nav_btn(self, text, row, command, color):
        if color == "gray":
             btn = ctk.CTkButton(self.sidebar, text=text, command=command, height=50, corner_radius=0, fg_color="transparent", text_color=("gray10", "gray90"), hover_color=("gray70", "gray30"), anchor="w", font=ctk.CTkFont(size=16))
        else:
             btn = ctk.CTkButton(self.sidebar, text=text, command=command, height=50, corner_radius=0, fg_color="transparent", text_color=color, hover_color=("gray70", "gray30"), anchor="w", font=ctk.CTkFont(size=16, weight="bold"))
        btn.grid(row=row, column=0, sticky="ew")
        return btn
    
    def change_appearance_mode_event(self, new_appearance_mode: str):
        ctk.set_appearance_mode(new_appearance_mode)

    def show_dashboard(self): self.tabview.set("Dashboard"); self.frames["Dashboard"].refresh()
    def show_herd(self): self.tabview.set("Herd"); self.frames["Herd"].refresh()
    def show_health(self): self.tabview.set("Health"); self.frames["Health"].refresh()
    def show_breeding(self): self.tabview.set("Breeding"); self.frames["Breeding"].refresh()
    def show_reports(self): self.tabview.set("Reports"); self.frames["Reports"].refresh()

class BaseFrame(ctk.CTkFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, fg_color="transparent")
        self.controller = controller
        self.db = controller.db
    
    def create_treeview(self, columns):
        style = ttk.Style()
        style.theme_use("clam")
        style.configure("Treeview", background="#2b2b2b", fieldbackground="#2b2b2b", foreground="white", rowheight=60, borderwidth=1, relief="solid", font=('Arial', 22))
        style.configure("Treeview.Heading", background="#1f1f1f", foreground="white", font=('Arial', 22, 'bold'), relief="raised")
        style.map("Treeview", background=[('selected', '#1f6aa5')])
        tree = ttk.Treeview(self, columns=columns, show='headings', style="Treeview")
        for c in columns: tree.heading(c, text=c)
        scroll = ctk.CTkScrollbar(self, command=tree.yview)
        tree.configure(yscrollcommand=scroll.set)
        scroll.pack(side="right", fill="y")
        tree.pack(fill="both", expand=True, padx=5, pady=5)
        return tree
    
    def create_glass_btn(self, parent, text, cmd, color="blue", width=100):
        border = "#5c7cfa" 
        if color == "red": border = "#ef5350"
        if color == "green": border = "#66bb6a"
        if color == "orange": border = "#ff9800"
        return ctk.CTkButton(parent, text=text, command=cmd, width=width, height=40, fg_color="#2b2b2b", border_width=2, border_color=border, hover_color="#3a3a3a")

# ==========================
# DASHBOARD
# ==========================
class DashboardFrame(BaseFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, controller)
        top = ctk.CTkFrame(self, fg_color="transparent")
        top.pack(fill="x", pady=10)
        ctk.CTkLabel(top, text="Dashboard", font=ctk.CTkFont(size=24, weight="bold")).pack(side="left")
        self.create_glass_btn(top, "Refresh", self.refresh, "blue").pack(side="right")
        self.tree = self.create_treeview(("Type", "Goat", "Task", "Due In", "ID", "RecID"))
        self.tree.column("Type", width=150)
        self.tree.column("Goat", width=200)
        self.tree.column("Task", width=500)
        self.tree.column("Due In", width=200)
        self.tree.column("ID", width=0, stretch=False)
        self.tree.column("RecID", width=0, stretch=False)
        self.tree.tag_configure('overdue', foreground='#ff5555')
        self.tree.tag_configure('today', foreground='#ffb86c')
        self.tree.bind("<Double-1>", self.on_double_click)
        self.refresh()

    def refresh(self):
        for i in self.tree.get_children(): self.tree.delete(i)
        health, breeding = self.db.fetch_alerts_data()
        now = datetime.now()
        
        # Health
        for h in health:
            try: due = datetime.strptime(h['follow_up_date'], "%Y-%m-%d %H:%M:%S")
            except: due = datetime.strptime(h['follow_up_date'], "%Y-%m-%d")
            days = (due - now).days
            tag = 'normal'
            status = f"{days} days"
            if days < 0: tag='overdue'; status="OVERDUE"
            elif days == 0: tag='today'; status="TODAY"
            self.tree.insert("", "end", values=("MEDICAL", h['name'], f"{h['event_type']} (Dose {h['treatment_number']+1})", status, h['goat_id'], h['event_id']), tags=(tag,))
        
        # Breeding
        for b in breeding:
            breed_dt = datetime.strptime(b['breeding_date'], "%Y-%m-%d")
            days_bred = (now - breed_dt).days
            task = "Monitoring"
            tag = 'normal'

            if not b['pregnancy_confirmed']:
                if days_bred < 18:
                     task = "Waiting for Heat Cycle"
                elif 18 <= days_bred <= 25:
                     task = "ACTION: Check for Heat"
                     tag = 'today'
                elif days_bred > 25:
                     task = "ACTION: Overdue Heat Check"
                     tag = 'overdue'
            elif b['pregnancy_confirmed'] and not b['scan_confirmed']:
                if days_bred < 40:
                     task = "Monitoring (Early Preg)"
                elif days_bred >= 40:
                     task = "ACTION: Ultrasound/Blood Test"
                     tag = 'today'
            elif b['scan_confirmed']:
                if days_bred < 140:
                     task = "Gestation"
                else:
                     task = f"KIDDING WATCH (Due {b['expected_due_date']})"
                     tag = 'overdue'

            self.tree.insert("", "end", values=("BREEDING", b['name'], task, f"Day {days_bred}", b['goat_id'], b['record_id']), tags=(tag,))

    def on_double_click(self, event):
        sel = self.tree.selection()
        if not sel: return
        vals = self.tree.item(sel[0])['values']
        atype, goat_id, rec_id = vals[0], vals[4], vals[5]
        if atype == "MEDICAL":
            self.controller.show_health()
            self.controller.frames["Health"].jump_to_record(goat_id, rec_id)
        elif atype == "BREEDING":
            self.controller.show_breeding()
            self.controller.frames["Breeding"].jump_to_record(rec_id)

# ==========================
# HERD
# ==========================
class HerdFrame(BaseFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, controller)
        top = ctk.CTkFrame(self, fg_color="transparent")
        top.pack(fill="x", pady=10)
        self.create_glass_btn(top, "+ Add Goat", self.popup_add, "green", 120).pack(side="left", padx=5)
        self.create_glass_btn(top, "Edit", self.popup_edit, "blue", 80).pack(side="left", padx=5)
        self.create_glass_btn(top, "Profile", self.view_profile, "blue", 80).pack(side="left", padx=5)
        self.create_glass_btn(top, "Lineage", self.trace_lineage, "blue", 80).pack(side="left", padx=5)
        self.show_archived = ctk.BooleanVar(value=False)
        ctk.CTkSwitch(top, text="Show Archived", variable=self.show_archived, command=self.refresh).pack(side="right", padx=10)
        self.create_glass_btn(top, "Archive", self.action_archive, "red", 80).pack(side="right", padx=5)
        self.create_glass_btn(top, "Restore", self.action_restore, "green", 80).pack(side="right", padx=5)
        self.tree = self.create_treeview(("ID", "Tag", "Name", "Breed", "Sex", "DOB", "Age", "Status"))
        self.tree.column("ID", width=60)
        self.tree.column("Tag", width=120)
        self.tree.bind("<Double-1>", lambda e: self.view_profile())
        self.refresh()

    def refresh(self):
        for i in self.tree.get_children(): self.tree.delete(i)
        if self.show_archived.get():
            rows = self.db.fetch_archived_goats()
            for r in rows: self.tree.insert("", "end", values=(r['id'], r['tag_number'], r['name'], r['breed'], r['sex'], r['archive_date'], "ARCHIVED", r['archive_reason']))
        else:
            rows = self.db.fetch_active_goats()
            for r in rows:
                age = self.calculate_age(r['date_of_birth'])
                self.tree.insert("", "end", values=(r['id'], r['tag_number'], r['name'], r['breed'], r['sex'], r['date_of_birth'], age, "Active"))

    def popup_add(self): AddGoatPopup(self.controller, self.refresh)
    def popup_edit(self):
        sel = self.tree.selection()
        if not sel: return
        gid = self.tree.item(sel[0])['values'][0]
        AddGoatPopup(self.controller, self.refresh, goat_id=gid)
    def action_archive(self):
        sel = self.tree.selection()
        if not sel: return
        gid = self.tree.item(sel[0])['values'][0]
        ArchivePopup(self.controller, gid, self.refresh)
    def action_restore(self):
        sel = self.tree.selection()
        if not sel: return
        if not self.show_archived.get(): messagebox.showwarning("Error", "Switch to Archived view first."); return
        gid = self.tree.item(sel[0])['values'][0]
        if messagebox.askyesno("Restore", "Restore?"): self.db.restore_goat(gid); self.refresh()
    def view_profile(self):
        sel = self.tree.selection()
        if not sel: return
        gid = self.tree.item(sel[0])['values'][0]
        ProfileWindow(self.controller, gid)
    def trace_lineage(self):
        sel = self.tree.selection()
        if not sel: return
        gid = self.tree.item(sel[0])['values'][0]
        LineagePopup(self.controller, gid)
    def calculate_age(self, dob_str):
        try:
            dob = datetime.strptime(dob_str, "%Y-%m-%d")
            delta = datetime.now() - dob
            if delta.days < 30: return f"{delta.days} d"
            if delta.days < 365: return f"{int(delta.days/30)} m"
            return f"{int(delta.days/365)} y"
        except: return "?"

# ==========================
# HEALTH
# ==========================
class HealthFrame(BaseFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, controller)
        top = ctk.CTkFrame(self, fg_color="transparent")
        top.pack(fill="x", pady=10)
        ctk.CTkLabel(top, text="Goat:").pack(side="left", padx=5)
        self.combo_var = ctk.StringVar()
        self.combo = ctk.CTkComboBox(top, width=250, variable=self.combo_var, command=self.load_history)
        self.combo.pack(side="left", padx=5)
        self.create_glass_btn(top, "+ Log Event", self.popup_log, "green").pack(side="left", padx=20)
        self.create_glass_btn(top, "++ Batch / Herd Log", self.popup_batch, "orange", width=200).pack(side="left", padx=5)
        self.create_glass_btn(top, "Edit Event", self.popup_edit, "blue").pack(side="left", padx=5)
        self.create_glass_btn(top, "Delete", self.delete_evt, "red").pack(side="left", padx=5)
        self.tree = self.create_treeview(("ID", "Date", "Type", "Weight", "Dosage", "Cost", "Admin", "Img", "Details"))
        self.tree.column("ID", width=30)
        self.tree.column("Img", width=40, anchor='center')
        self.tree.bind("<Double-1>", lambda e: self.popup_edit())
        self.refresh()

    def refresh(self):
        goats = self.db.fetch_active_goats()
        self.goat_map = {f"{g['name']} ({g['tag_number']})": g['id'] for g in goats}
        self.id_map = {g['id']: f"{g['name']} ({g['tag_number']})" for g in goats}
        self.combo.configure(values=list(self.goat_map.keys()))

    def load_history(self, choice):
        for i in self.tree.get_children(): self.tree.delete(i)
        if not choice or choice not in self.goat_map: return
        gid = self.goat_map[choice]
        rows = self.db.fetch_health_history(gid)
        for r in rows:
            c = f"${r['cost']:.2f}" if r['cost'] else "-"
            w = f"{r['weight_recorded']}" if r['weight_recorded'] else "-"
            admin = r['performed_by'] if r['performed_by'] else "-"
            d_txt = r['details']
            t_tot = r['total_treatments_needed'] if r['total_treatments_needed'] else 0
            t_num = r['treatment_number'] if r['treatment_number'] else 0
            if t_tot > 1: d_txt += f" [Dose {t_num}/{t_tot}]"
            has_img = "-"
            if r['image_path']:
                if r['image_path'].lower().endswith('.pdf'): has_img = "PDF"
                else: has_img = "IMG"
            self.tree.insert("", "end", values=(r['id'], r['event_date'], r['event_type'], w, r['dosage'], c, admin, has_img, d_txt))

    def jump_to_record(self, goat_id, event_id):
        if goat_id in self.id_map:
            name = self.id_map[goat_id]
            self.combo.set(name)
            self.load_history(name)
            for child in self.tree.get_children():
                vals = self.tree.item(child)['values']
                if str(vals[0]) == str(event_id):
                    self.tree.selection_set(child)
                    self.tree.see(child)
                    break

    def popup_log(self):
        sel = self.combo.get()
        if not sel or sel not in self.goat_map: 
             messagebox.showwarning("Warning", "Please select a valid goat first.")
             return
        gid = self.goat_map[sel]
        LogHealthPopup(self.controller, gid, self.load_history, sel)

    def popup_batch(self):
        BatchHealthPopup(self.controller, self.refresh)
    
    def popup_edit(self):
        sel = self.tree.selection()
        if not sel: return
        event_id = self.tree.item(sel[0])['values'][0]
        sel_string = self.combo.get()
        goat_id = self.goat_map[sel_string]
        EditHealthPopup(self.controller, goat_id, self.load_history, sel_string, event_id)

    def delete_evt(self):
        sel = self.tree.selection()
        if not sel: return
        if messagebox.askyesno("Delete", "Delete record?"):
            eid = self.tree.item(sel[0])['values'][0]
            self.db.delete_health_event(eid)
            self.load_history(self.combo.get())

# ==========================
# BREEDING
# ==========================
class BreedingFrame(BaseFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, controller)
        top = ctk.CTkFrame(self, fg_color="transparent")
        top.pack(fill="x", pady=10)
        self.create_glass_btn(top, "+ Log Pairing", self.popup_pair, "green").pack(side="left", padx=5)
        self.create_glass_btn(top, "Update Status", self.popup_status, "blue").pack(side="left", padx=5)
        self.create_glass_btn(top, "Record Kidding", self.popup_kid, "blue").pack(side="left", padx=5)
        self.create_glass_btn(top, "Edit", self.popup_edit, "blue").pack(side="left", padx=20)
        self.create_glass_btn(top, "Delete", self.delete_rec, "red").pack(side="left", padx=5)
        self.create_glass_btn(top, "Refresh", self.refresh, "blue").pack(side="right", padx=5)
        self.tree = self.create_treeview(("ID", "Doe", "Buck", "Due Date", "Days Left", "Status"))
        self.tree.column("ID", width=30)
        self.tree.bind("<Double-1>", lambda e: self.popup_edit())
        self.refresh()

    def refresh(self):
        for i in self.tree.get_children(): self.tree.delete(i)
        rows = self.db.fetch_breeding_records()
        now = datetime.now()
        for r in rows:
            status = "Pending Heat Check"
            days_left = "-"
            if r['pregnancy_confirmed'] or r['scan_confirmed']:
                try:
                    due = datetime.strptime(r['expected_due_date'], "%Y-%m-%d")
                    delta = (due - now).days
                    days_left = f"{delta} days"
                except: pass
            if r['pregnancy_confirmed']: status = "Heat Passed"
            if r['scan_confirmed']: status = "CONFIRMED PREGNANT"
            if r['kidding_date']: 
                status = f"Kidded: {r['kidding_date']} ({r['kids_count']})"
                days_left = "Done"
            buck_name = r['buck'] if r['buck'] else "Unknown"
            self.tree.insert("", "end", values=(r['id'], r['doe'], buck_name, r['expected_due_date'], days_left, status))

    def jump_to_record(self, rec_id):
        self.refresh()
        for child in self.tree.get_children():
            vals = self.tree.item(child)['values']
            if str(vals[0]) == str(rec_id):
                self.tree.selection_set(child)
                self.tree.see(child)
                break

    def popup_pair(self): BreedingPopup(self.controller, self.refresh)
    def popup_status(self):
        sel = self.tree.selection()
        if not sel: return
        rid = self.tree.item(sel[0])['values'][0]
        BreedingStatusPopup(self.controller, rid, self.refresh)
    def popup_kid(self):
        sel = self.tree.selection()
        if not sel: return
        rid = self.tree.item(sel[0])['values'][0]
        KiddingPopup(self.controller, rid, self.refresh)
    def popup_edit(self):
        sel = self.tree.selection()
        if not sel: return
        rid = self.tree.item(sel[0])['values'][0]
        BreedingPopup(self.controller, self.refresh, rec_id=rid)
    def delete_rec(self):
        sel = self.tree.selection()
        if not sel: return
        if messagebox.askyesno("Delete", "Delete this breeding record?"):
            rid = self.tree.item(sel[0])['values'][0]
            self.db.delete_breeding_record(rid)
            self.refresh()

# ==========================
# REPORTS
# ==========================
class ReportsFrame(BaseFrame):
    def __init__(self, parent, controller):
        super().__init__(parent, controller)
        f = ctk.CTkFrame(self, fg_color="transparent")
        f.pack(padx=50, pady=20, fill="both", expand=True)
        f_config = ctk.CTkFrame(f, fg_color="transparent")
        f_config.pack(fill="x", pady=10)
        self.create_glass_btn(f_config, "⚙️ Configure Email", self.popup_config_email, width=200).pack(side="right")
        self.create_glass_btn(f_config, "📂 Load Backup File", self.load_backup, "orange", 200).pack(side="right", padx=10)
        self.create_glass_btn(f_config, "💾 Create Backup", self.backup_db, "green", 200).pack(side="right", padx=10)
        ctk.CTkLabel(f, text="Global Reports (PDF)", font=ctk.CTkFont(size=20, weight="bold")).pack(pady=10)
        
        def make_row(txt, cmd_pdf, cmd_email):
            row = ctk.CTkFrame(f, fg_color="transparent")
            row.pack(fill="x", pady=5)
            self.create_glass_btn(row, f"📄 {txt}", cmd_pdf, "blue", 400).pack(side="left", fill="x", expand=True, padx=(0,5))
            self.create_glass_btn(row, "📧 Email", cmd_email, "blue", 100).pack(side="right")

        make_row("Barn Checklist (Alerts)", self.pdf_alert, lambda: self.email_text_report(self.get_text_alert))
        make_row("Herd Roll Call", self.pdf_herd, lambda: self.email_text_report(self.get_text_herd))
        make_row("Master Health Log", self.pdf_health, lambda: self.email_text_report(self.get_text_health))
        make_row("Breeding Report", self.pdf_breed, lambda: self.email_text_report(self.get_text_breed))
        
        ctk.CTkLabel(f, text="Dossier", font=ctk.CTkFont(size=20, weight="bold")).pack(pady=(30,10))
        self.combo = ctk.CTkComboBox(f, values=[], height=50, width=400)
        self.combo.pack(pady=5, fill="x")
        row_d = ctk.CTkFrame(f, fg_color="transparent")
        row_d.pack(fill="x", pady=5)
        
        # WEIGHT GRAPH
        self.create_glass_btn(row_d, "📈 Weight Graph", self.popup_weight_graph, "orange").pack(side="left", padx=(0,5))

        self.create_glass_btn(row_d, "🖨️ Print Dossier PDF", self.pdf_dossier, "blue").pack(side="left", fill="x", expand=True, padx=(0,5))
        self.create_glass_btn(row_d, "📧 Email", lambda: self.email_text_report(self.get_text_dossier), "blue", 100).pack(side="right")
        self.refresh()

    def refresh(self):
        goats = self.db.fetch_active_goats()
        vals = [f"{g['name']} ({g['tag_number']}) [{g['id']}]" for g in goats]
        self.combo.configure(values=vals)

    def popup_config_email(self):
        EmailConfigPopup(self.controller)

    def popup_weight_graph(self):
        if not HAS_MATPLOTLIB:
            messagebox.showerror("Error", "Matplotlib not installed. Run: pip install matplotlib")
            return
        sel = self.combo.get()
        if not sel: 
            messagebox.showwarning("Select Goat", "Please select a goat from the Dossier dropdown.")
            return
        gid = sel.split('[')[1].strip(']')
        WeightChartPopup(self.controller, gid, sel)

    def backup_db(self):
        res = self.db.create_backup()
        if res: messagebox.showinfo("Success", f"Backup created:\n{res}")
        else: messagebox.showerror("Error", "Backup failed.")

    def load_backup(self):
        if not messagebox.askyesno("Confirm Load", "WARNING: Loading a backup will OVERWRITE your current data. Continue?"):
            return
        filename = filedialog.askopenfilename(title="Select Backup DB", filetypes=[("SQLite DB", "*.db")])
        if filename:
            if self.db.restore_backup(filename):
                messagebox.showinfo("Success", "Backup Restored. Please restart the app.")
                self.controller.destroy()
            else: messagebox.showerror("Error", "Failed to restore backup.")

    def email_text_report(self, text_generator):
        body_text = text_generator()
        if not body_text: return
        recipient = self.db.load_email_config()
        subject = urllib.parse.quote("Goat Manager Report")
        body_safe = urllib.parse.quote(body_text)
        mailto = f"mailto:{recipient}?subject={subject}&body={body_safe}"
        try: webbrowser.open(mailto)
        except: messagebox.showerror("Error", "Could not open email client.")

    # --- TEXT GENERATORS ---
    def get_text_alert(self):
        h, b = self.db.fetch_alerts_data()
        txt = "BARN CHECKLIST (ALERTS)\n=======================\n\nHEALTH TASKS:\n"
        for x in h: txt += f"[ ] {x['name']} ({x['tag_number']}): {x['event_type']} Dose {x['treatment_number']+1}\n"
        txt += "\nBREEDING TASKS:\n"
        for y in b:
            if not y['pregnancy_confirmed']: t = f"Heat Check: {y['name']}"
            elif not y['scan_confirmed']: t = f"Pregnancy Scan: {y['name']}"
            else: t = f"Kidding Watch: {y['name']} (Due {y['expected_due_date']})"
            txt += f"[ ] {t}\n"
        return txt

    def get_text_herd(self):
        g = self.db.fetch_active_goats()
        txt = "HERD ROLL CALL\n==============\n"
        for x in g: txt += f"{x['tag_number']} - {x['name']} ({x['sex']}) DOB: {x['date_of_birth']}\n"
        return txt

    def get_text_health(self):
        r = self.db.fetch_all_health_events()
        txt = "MASTER HEALTH LOG\n=================\n"
        for x in r: txt += f"{x['event_date']} | {x['name']} | {x['event_type']} | ${x['cost']}\n"
        return txt

    def get_text_breed(self):
        r = self.db.fetch_breeding_records()
        txt = "BREEDING REPORT\n===============\n"
        for x in r: txt += f"{x['doe']} x {x['buck']} -> Due {x['expected_due_date']}\n"
        return txt

    def get_text_dossier(self):
        sel = self.combo.get()
        if not sel: return None
        gid = sel.split('[')[1].strip(']')
        g = self.db.fetch_goat_details(gid)
        meds = self.db.fetch_health_history(gid)
        txt = f"DOSSIER: {g['name']} ({g['tag_number']})\n"
        txt += f"Breed: {g['breed']} | Sex: {g['sex']} | DOB: {g['date_of_birth']}\n"
        txt += "\nMEDICAL HISTORY:\n"
        for m in meds: txt += f"{m['event_date']}: {m['event_type']} - {m['details']}\n"
        return txt

    # --- PDF GENERATORS ---
    def pdf_alert(self, return_filename_only=False):
        h, b = self.db.fetch_alerts_data()
        pdf = FPDF(); pdf.add_page(); pdf.set_font("Helvetica", size=12)
        pdf.cell(0, 10, text=f"BARN CHECKLIST - {datetime.now().strftime('%Y-%m-%d')}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        pdf.ln(10)
        pdf.set_font("Helvetica", 'B', 12); pdf.cell(0, 10, text="HEALTH TASKS", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_font("Helvetica", size=12)
        for x in h: pdf.cell(0, 10, text=f"[ ] {x['name']} ({x['tag_number']}): {x['event_type']} Dose {x['treatment_number']+1}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.ln(5)
        pdf.set_font("Helvetica", 'B', 12); pdf.cell(0, 10, text="BREEDING TASKS", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_font("Helvetica", size=12)
        for y in b:
            if not y['pregnancy_confirmed']: txt = f"[ ] {y['name']}: Heat Check"
            elif not y['scan_confirmed']: txt = f"[ ] {y['name']}: Pregnancy Scan"
            else: txt = f"[ ] {y['name']}: Kidding Watch (Due {y['expected_due_date']})"
            pdf.cell(0, 10, text=txt, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        fn = os.path.join(REPORTS_DIR, f"Barn_Checklist_{datetime.now().strftime('%Y%m%d')}.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def pdf_herd(self, return_filename_only=False):
        g = self.db.fetch_active_goats()
        pdf = FPDF(); pdf.add_page(); pdf.set_font("Helvetica", 'B', 16)
        pdf.cell(0, 10, text="ACTIVE HERD ROLL CALL", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        pdf.set_font("Helvetica", 'B', 12)
        pdf.cell(40, 10, text="Tag", border=1); pdf.cell(60, 10, text="Name", border=1); pdf.cell(30, 10, text="Sex", border=1); pdf.cell(40, 10, text="DOB", border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_font("Helvetica", size=12)
        for x in g:
            pdf.cell(40, 10, text=str(x['tag_number']), border=1)
            pdf.cell(60, 10, text=str(x['name']), border=1)
            pdf.cell(30, 10, text=str(x['sex']), border=1)
            pdf.cell(40, 10, text=str(x['date_of_birth']), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        fn = os.path.join(REPORTS_DIR, "Herd_RollCall.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def pdf_health(self, return_filename_only=False):
        r = self.db.fetch_all_health_events()
        pdf = FPDF(); pdf.add_page(); pdf.set_font("Helvetica", 'B', 16); pdf.cell(0, 10, text="MASTER HEALTH LOG", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        pdf.set_font("Helvetica", 'B', 10)
        pdf.cell(30, 10, text="Date", border=1); pdf.cell(40, 10, text="Goat", border=1); pdf.cell(40, 10, text="Type", border=1); pdf.cell(20, 10, text="Cost", border=1); pdf.cell(60, 10, text="Detail", border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_font("Helvetica", size=10)
        for x in r:
            c = f"${x['cost']}" if x['cost'] else "-"
            pdf.cell(30, 10, text=str(x['event_date']), border=1)
            pdf.cell(40, 10, text=str(x['name']), border=1)
            pdf.cell(40, 10, text=str(x['event_type']), border=1)
            pdf.cell(20, 10, text=c, border=1)
            pdf.cell(60, 10, text=str(x['details']), border=1, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        fn = os.path.join(REPORTS_DIR, "Health_Log.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def pdf_breed(self, return_filename_only=False):
        r = self.db.fetch_breeding_records()
        pdf = FPDF(); pdf.add_page(); pdf.set_font("Helvetica", 'B', 16); pdf.cell(0, 10, text="BREEDING REPORT", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        pdf.set_font("Helvetica", size=12)
        for x in r:
            pdf.cell(0, 10, text=f"{x['doe']} x {x['buck']} -> Due {x['expected_due_date']}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        fn = os.path.join(REPORTS_DIR, "Breeding.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def pdf_pedigree(self, return_filename_only=False):
        sel = self.combo.get()
        if not sel: return
        gid = sel.split('[')[1].strip(']')
        tree = self.controller.db.fetch_pedigree_tree(gid)
        pdf = FPDF('L', 'mm', 'A4'); pdf.add_page(); pdf.set_font("Helvetica", 'B', 16)
        pdf.cell(0, 10, text=f"PEDIGREE: {tree['me']['name']}", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        def draw_box(x, y, w, h, txt):
            pdf.rect(x, y, w, h)
            pdf.set_xy(x, y + h/3)
            pdf.set_font("Helvetica", size=10)
            if txt: pdf.multi_cell(w, 5, text=txt, align='C')
        w = 50; h = 30
        draw_box(20, 85, w, h, f"{tree['me']['name']}\n{tree['me']['tag_number']}")
        s = tree['sire']; d = tree['dam']
        s_txt = f"{s['name']}\n{s['tag_number']}" if s else "Unknown"
        d_txt = f"{d['name']}\n{d['tag_number']}" if d else "Unknown"
        draw_box(80, 45, w, h, s_txt); draw_box(80, 125, w, h, d_txt)
        ss = tree['ss']; sd = tree['sd']; ds = tree['ds']; dd = tree['dd']
        draw_box(150, 25, w, h, f"{ss['name']}" if ss else "Unknown")
        draw_box(150, 65, w, h, f"{sd['name']}" if sd else "Unknown")
        draw_box(150, 105, w, h, f"{ds['name']}" if ds else "Unknown")
        draw_box(150, 145, w, h, f"{dd['name']}" if dd else "Unknown")
        pdf.line(70, 100, 80, 60); pdf.line(70, 100, 80, 140)
        pdf.line(130, 60, 150, 40); pdf.line(130, 60, 150, 80)
        pdf.line(130, 140, 150, 120); pdf.line(130, 140, 150, 160)
        fn = os.path.join(REPORTS_DIR, f"Pedigree_{tree['me']['tag_number']}.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def pdf_dossier(self, return_filename_only=False):
        sel = self.combo.get()
        if not sel: return
        gid = sel.split('[')[1].strip(']')
        g = self.db.fetch_goat_details(gid)
        meds = self.db.fetch_health_history(gid)
        bre = self.db.fetch_full_breeding_history(gid, g['sex'])
        pdf = FPDF(); pdf.add_page(); pdf.set_font("Helvetica", 'B', 16)
        pdf.cell(0, 10, text=f"DOSSIER: {g['name']} ({g['tag_number']})", new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
        if g['profile_image'] and os.path.exists(g['profile_image']):
            pdf.image(g['profile_image'], x=10, y=30, w=50); pdf.set_xy(70, 30)
        else: pdf.set_xy(10, 30)
        pdf.set_font("Helvetica", size=12)
        pdf.cell(0, 10, text=f"Breed: {g['breed']}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_x(70 if g['profile_image'] else 10)
        pdf.cell(0, 10, text=f"Sex: {g['sex']} | DOB: {g['date_of_birth']}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.ln(40)
        pdf.set_font("Helvetica", 'B', 14); pdf.cell(0, 10, text="MEDICAL HISTORY", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        pdf.set_font("Helvetica", size=10)
        for m in meds:
            pdf.set_font("Helvetica", 'B', 10)
            pdf.cell(40, 6, text=f"Date: {m['event_date']}", border=0, new_x=XPos.RIGHT, new_y=YPos.TOP)
            pdf.cell(50, 6, text=f"Type: {m['event_type']}", border=0, new_x=XPos.RIGHT, new_y=YPos.TOP)
            pdf.cell(40, 6, text=f"Admin: {m['performed_by'] or '-'}", border=0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
            pdf.set_font("Helvetica", size=10)
            pdf.multi_cell(0, 6, text=f"Weight: {m['weight_recorded'] or '-'} | Dosage: {m['dosage'] or '-'} | Cost: ${m['cost'] or 0}\nDetails: {m['details']}", border='B')
            pdf.ln(2)
        pdf.add_page(); pdf.set_font("Helvetica", 'B', 14); pdf.cell(0, 10, text="BREEDING HISTORY", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
        for b in bre:
            pdf.set_font("Helvetica", 'B', 10)
            pdf.cell(40, 6, text=f"Bred: {b['breeding_date']}", border=0, new_x=XPos.RIGHT, new_y=YPos.TOP)
            pdf.cell(60, 6, text=f"Partner: {b['partner_name']} ({b['partner_tag']})", border=0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
            status = "Pending"
            if b['pregnancy_confirmed']: status = "Confirmed"
            if b['kidding_date']: status = f"Kidded ({b['kids_count']} kids)"
            pdf.set_font("Helvetica", size=10)
            pdf.multi_cell(0, 6, text=f"Status: {status} | Due: {b['expected_due_date']}\nResult: {b['kidding_date'] or 'Pending'}", border='B')
            pdf.ln(2)
        fn = os.path.join(REPORTS_DIR, f"Dossier_{g['tag_number']}.pdf")
        pdf.output(fn)
        if return_filename_only: return fn
        self.open_file(fn)

    def open_file(self, filename):
        try:
            if platform.system() == 'Windows': os.startfile(filename)
            elif platform.system() == 'Darwin': subprocess.call(('open', filename))
            else: subprocess.call(('xdg-open', filename))
        except: messagebox.showinfo("Saved", f"Saved to {filename}")

# ==========================
# POPUPS
# ==========================
class WeightChartPopup(ctk.CTkToplevel):
    def __init__(self, controller, goat_id, title_str):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.title(f"Weight Trend: {title_str}")
        self.geometry("800x600")
        self.lift(); self.focus_force(); self.grab_set()
        
        data = self.controller.db.fetch_weight_data(goat_id)
        
        if not data:
            ctk.CTkLabel(self, text="No weight records found.", font=ctk.CTkFont(size=20)).pack(expand=True)
            return
            
        dates = [datetime.strptime(d['event_date'], "%Y-%m-%d") for d in data]
        weights = [d['weight_recorded'] for d in data]

        fig, ax = plt.subplots(figsize=(8, 6), dpi=100)
        ax.plot(dates, weights, marker='o', linestyle='-', color='b')
        ax.set_title("Weight Over Time")
        ax.set_xlabel("Date")
        ax.set_ylabel("Weight (lbs)")
        ax.grid(True)
        plt.setp(ax.get_xticklabels(), rotation=45, ha="right")
        fig.tight_layout()

        canvas = FigureCanvasTkAgg(fig, master=self)
        canvas.draw()
        canvas.get_tk_widget().pack(fill="both", expand=True)

class EmailConfigPopup(ctk.CTkToplevel):
    def __init__(self, controller):
        super().__init__()
        self.attributes("-topmost", True)
        self.db = controller.db
        self.title("Email Configuration")
        self.geometry("500x400")
        self.lift(); self.focus_force(); self.grab_set()

        ctk.CTkLabel(self, text="Default Recipient Email:", font=ctk.CTkFont(size=20, weight="bold")).pack(pady=(50,10))
        self.e_email = ctk.CTkEntry(self, width=400, height=50, font=ctk.CTkFont(size=18))
        self.e_email.pack(pady=10)
        self.e_email.insert(0, self.db.load_email_config())
        ctk.CTkButton(self, text="SAVE CONFIG", width=200, height=60, font=ctk.CTkFont(size=18, weight="bold"), command=self.save).pack(pady=30)
    def save(self):
        self.db.save_email_config(self.e_email.get())
        self.destroy()

class AddGoatPopup(ctk.CTkToplevel):
    def __init__(self, controller, refresh_cb, goat_id=None, pre_dob=None, pre_dam=None, pre_sire=None, title="Add Goat"):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.refresh_cb = refresh_cb
        self.goat_id = goat_id
        self.title(title)
        self.geometry("400x850")
        self.lift(); self.focus_force(); self.grab_set()
        
        # SCROLLABLE FRAME
        self.scroll = ctk.CTkScrollableFrame(self, width=400, height=850)
        self.scroll.pack(fill="both", expand=True)
        
        self.e_name = self.entry("Name")
        self.e_tag = self.entry("Tag #")
        self.e_reg = self.entry("Reg #")
        self.e_breed = self.entry("Breed")
        
        ctk.CTkLabel(self.scroll, text="Sex").pack()
        self.e_sex = ctk.CTkComboBox(self.scroll, values=["Doe", "Buck", "Wether"])
        self.e_sex.pack()
        
        self.e_dob = self.entry("DOB (YYYY-MM-DD)")
        if pre_dob: self.e_dob.insert(0, pre_dob)
        
        # --- TOGGLE SOURCE ---
        ctk.CTkLabel(self.scroll, text="Origin").pack(pady=(10,0))
        self.var_source = ctk.StringVar(value="Farm Born")
        self.seg_source = ctk.CTkSegmentedButton(self.scroll, values=["Farm Born", "Purchased"], variable=self.var_source, command=self.toggle_source)
        self.seg_source.pack(pady=5)

        self.f_purch = ctk.CTkFrame(self.scroll)
        self.e_source_name = self.entry_in(self.f_purch, "Purchased From:")
        self.e_price = self.entry_in(self.f_purch, "Price ($):")
        
        ctk.CTkLabel(self.scroll, text="Dam").pack()
        self.c_dam = ctk.CTkComboBox(self.scroll, values=self.get_list("Doe"))
        self.c_dam.pack()
        if pre_dam: self.set_combo(self.c_dam, pre_dam)
        
        ctk.CTkLabel(self.scroll, text="Sire").pack()
        self.c_sire = ctk.CTkComboBox(self.scroll, values=self.get_list("Buck"))
        self.c_sire.pack()
        if pre_sire: self.set_combo(self.c_sire, pre_sire)

        self.img_path = None
        ctk.CTkButton(self.scroll, text="📷 Upload Photo", fg_color="#5c7cfa", command=self.upload_photo).pack(pady=15)
        self.lbl_img = ctk.CTkLabel(self.scroll, text="No image selected", text_color="gray")
        self.lbl_img.pack()

        if goat_id:
            g = self.controller.db.fetch_goat_by_id(goat_id)
            self.e_name.insert(0, g['name'])
            self.e_tag.insert(0, g['tag_number'])
            self.e_reg.insert(0, g['registration_number'])
            self.e_breed.insert(0, g['breed'])
            self.e_sex.set(g['sex'])
            self.e_dob.insert(0, g['date_of_birth'])
            
            if g['source'] != "Farm Born":
                self.var_source.set("Purchased")
                self.toggle_source("Purchased")
                self.e_source_name.insert(0, g['source'])
                self.e_price.insert(0, g['purchase_price'])
            
            if g['dam_id']: self.set_combo(self.c_dam, g['dam_id'])
            if g['sire_id']: self.set_combo(self.c_sire, g['sire_id'])
            
            if g['profile_image']:
                self.img_path = g['profile_image']
                self.lbl_img.configure(text=os.path.basename(self.img_path))

        ctk.CTkButton(self.scroll, text="SAVE", fg_color="green", height=50, font=ctk.CTkFont(size=18, weight="bold"), command=self.save).pack(pady=30)

    def upload_photo(self):
        path = filedialog.askopenfilename(parent=self, filetypes=[("Images", "*.png;*.jpg;*.jpeg")])
        if path:
            dest = os.path.join(UPLOAD_DIR, os.path.basename(path))
            shutil.copy(path, dest)
            self.img_path = dest
            self.lbl_img.configure(text=os.path.basename(dest))

    def toggle_source(self, val):
        if val == "Purchased": self.f_purch.pack(pady=5)
        else: self.f_purch.pack_forget()

    def entry(self, txt):
        ctk.CTkLabel(self.scroll, text=txt).pack(pady=(5,0))
        e = ctk.CTkEntry(self.scroll)
        e.pack()
        return e
        
    def entry_in(self, parent, txt):
        ctk.CTkLabel(parent, text=txt).pack(pady=(2,0))
        e = ctk.CTkEntry(parent)
        e.pack()
        return e

    def get_list(self, sex):
        rows = self.controller.db.fetch_active_goats(sex)
        lst = [f"{r['name']} ({r['tag_number']}) [{r['id']}]" for r in rows]
        lst.insert(0, "Unknown [None]")
        return lst

    def set_combo(self, combo, tid):
        for v in combo._values:
            if v.endswith(f"[{tid}]"): combo.set(v); break

    def get_id_from_combo(self, combo_str):
        if not combo_str or "Unknown" in combo_str: return None
        try: return combo_str.split('[')[1].strip(']')
        except: return None

    def save(self):
        did = self.get_id_from_combo(self.c_dam.get())
        sid = self.get_id_from_combo(self.c_sire.get())
        src = "Farm Born"
        price = 0
        if self.var_source.get() == "Purchased":
            src = self.e_source_name.get()
            price = float(self.e_price.get()) if self.e_price.get() else 0
        
        if self.goat_id:
             self.controller.db.update_goat(self.goat_id, self.e_name.get(), self.e_tag.get(), self.e_reg.get(), self.e_breed.get(), self.e_dob.get(), self.e_sex.get(), sid, did, self.img_path)
        else:
             self.controller.db.add_goat(self.e_name.get(), self.e_tag.get(), self.e_reg.get(), self.e_breed.get(), self.e_dob.get(), self.e_sex.get(), sid, did, src, price, self.img_path)
        
        self.refresh_cb()
        self.destroy()

class LogHealthPopup(ctk.CTkToplevel):
    def __init__(self, controller, goat_id, cb, selection_key):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.goat_id = goat_id
        self.cb = cb
        self.selection_key = selection_key
        self.title(f"Log for {selection_key}")
        self.geometry("450x750")
        self.lift(); self.focus_force(); self.grab_set()
        
        # SCROLLABLE FRAME
        self.scroll = ctk.CTkScrollableFrame(self, width=400, height=750)
        self.scroll.pack(fill="both", expand=True)

        ctk.CTkLabel(self.scroll, text="Type").pack()
        self.c_type = ctk.CTkComboBox(self.scroll, values=["Vaccination", "Deworming", "Hoof Trim", "Weight Check", "Injury/Illness"])
        self.c_type.pack()
        self.e_date = self.entry("Date", datetime.now().strftime("%Y-%m-%d"))
        self.e_wgt = self.entry("Weight")
        self.e_dose = self.entry("Dosage")
        self.e_cost = self.entry("Cost")
        self.e_admin = self.entry("Performed By (Admin)")
        self.e_det = self.entry("Details")
        
        # --- HEALTH PHOTO ---
        self.img_path = None
        ctk.CTkButton(self.scroll, text="📷 Upload Photo", fg_color="#5c7cfa", command=self.upload_photo).pack(pady=15)
        self.lbl_img = ctk.CTkLabel(self.scroll, text="No image", text_color="gray")
        self.lbl_img.pack()
        self.lbl_preview = ctk.CTkLabel(self.scroll, text="") # Actual image preview
        self.lbl_preview.pack(pady=5)
        self.lbl_preview.bind("<Double-Button-1>", lambda e: self.open_image(self.img_path))
        
        # NEW: OPEN BUTTON
        self.btn_open_file = ctk.CTkButton(self.scroll, text="📂 Open Attached File", state="disabled", fg_color="gray", command=lambda: self.open_image(self.img_path))
        self.btn_open_file.pack(pady=5)

        self.v_sched = ctk.IntVar()
        ctk.CTkCheckBox(self.scroll, text="Schedule Follow-up", variable=self.v_sched, command=self.toggle_sched).pack(pady=10)
        self.f_sched = ctk.CTkFrame(self.scroll) 
        self.e_dose_num = self.entry_in_frame(self.f_sched, "Dose # (e.g. 1)", "1")
        self.e_total = self.entry_in_frame(self.f_sched, "Total Doses (e.g. 3)", "1")
        ctk.CTkLabel(self.f_sched, text="Next Dose In:").pack()
        f_inner = ctk.CTkFrame(self.f_sched)
        f_inner.pack()
        self.e_qty = ctk.CTkEntry(f_inner, width=50); self.e_qty.pack(side='left')
        self.c_unit = ctk.CTkComboBox(f_inner, values=["Hours", "Days", "Weeks"], width=100); self.c_unit.pack(side='left')
        self.c_unit.set("Days")
        
        ctk.CTkButton(self.scroll, text="SAVE", command=self.save).pack(pady=10)

    def open_image(self, path):
        if path and os.path.exists(path):
            try:
                if platform.system() == 'Windows': os.startfile(path)
                elif platform.system() == 'Darwin': subprocess.call(('open', path))
                else: subprocess.call(('xdg-open', path))
            except: pass

    def upload_photo(self):
        path = filedialog.askopenfilename(parent=self, filetypes=[("Images", "*.png;*.jpg;*.jpeg")])
        if path:
            dest = os.path.join(UPLOAD_DIR, os.path.basename(path))
            shutil.copy(path, dest)
            self.img_path = dest
            self.lbl_img.configure(text=os.path.basename(dest), text_color="green")
            self.btn_open_file.configure(state="normal", fg_color="#5c7cfa") # Enable Button
            
            if dest.lower().endswith(('.png', '.jpg', '.jpeg')):
                 self.show_image_preview(dest)
            else:
                 self.lbl_preview.configure(image=None, text="📄 PDF Attached")

    def show_image_preview(self, path):
        if path and os.path.exists(path):
            try:
                img = Image.open(path)
                ctk_img = ctk.CTkImage(light_image=img, dark_image=img, size=(200, 200))
                self.lbl_preview.configure(image=ctk_img, text="")
                self.lbl_preview.image = ctk_img # Keep reference
            except: pass

    def toggle_sched(self):
        if self.v_sched.get(): self.f_sched.pack(fill='x', padx=20)
        else: self.f_sched.pack_forget()
    
    def entry(self, txt, val=""):
        ctk.CTkLabel(self.scroll, text=txt).pack(pady=(2,0))
        e = ctk.CTkEntry(self.scroll)
        e.pack()
        if val: e.insert(0, val)
        return e
    
    def entry_in_frame(self, parent, txt, val=""):
        ctk.CTkLabel(parent, text=txt).pack(pady=(2,0))
        e = ctk.CTkEntry(parent)
        e.pack()
        if val: e.insert(0, val)
        return e
    
    def save(self):
        w = float(self.e_wgt.get()) if self.e_wgt.get() else 0.0
        c = float(self.e_cost.get()) if self.e_cost.get() else 0.0
        t_num, t_tot, follow_up = 1, 1, None
        if self.v_sched.get():
            try:
                t_num = int(self.e_dose_num.get())
                t_tot = int(self.e_total.get())
                qty = int(self.e_qty.get())
                unit = self.c_unit.get()
                now = datetime.strptime(self.e_date.get(), "%Y-%m-%d")
                delta = None
                if unit == "Hours": delta = timedelta(hours=qty)
                elif unit == "Days": delta = timedelta(days=qty)
                elif unit == "Weeks": delta = timedelta(weeks=qty)
                follow_up = (now + delta).strftime("%Y-%m-%d")
            except: pass
        self.controller.db.add_health_event(self.goat_id, self.e_date.get(), self.c_type.get(), w, self.e_dose.get(), c, self.e_det.get(), self.e_admin.get(), t_num, t_tot, follow_up, self.img_path)
        self.cb(self.selection_key)
        self.destroy()

class EditHealthPopup(LogHealthPopup):
    def __init__(self, controller, goat_id, cb, selection_key, event_id):
        super().__init__(controller, goat_id, cb, selection_key, event_id) # Correctly call super
        self.event_id = event_id
        self.title(f"Edit Event")
        self.load_data()
    def load_data(self):
        evt = self.controller.db.fetch_health_event_by_id(self.event_id)
        self.c_type.set(evt['event_type'])
        self.e_date.delete(0, 'end'); self.e_date.insert(0, evt['event_date'])
        if evt['weight_recorded']: self.e_wgt.insert(0, evt['weight_recorded'])
        if evt['dosage']: self.e_dose.insert(0, evt['dosage'])
        if evt['cost']: self.e_cost.insert(0, evt['cost'])
        if evt['details']: self.e_det.insert(0, evt['details'])
        if evt['performed_by']: self.e_admin.insert(0, evt['performed_by'])
        if evt['image_path']:
             self.img_path = evt['image_path']
             self.lbl_img.configure(text=os.path.basename(evt['image_path']), text_color="green")
             self.btn_open_file.configure(state="normal", fg_color="#5c7cfa")
             if self.img_path.lower().endswith(('.png', '.jpg', '.jpeg')):
                  self.show_image_preview(self.img_path)
             else:
                  self.lbl_preview.configure(text="📄 PDF Attached")
    def save(self):
        w = float(self.e_wgt.get()) if self.e_wgt.get() else 0.0
        c = float(self.e_cost.get()) if self.e_cost.get() else 0.0
        self.controller.db.update_health_event(self.event_id, self.e_date.get(), self.c_type.get(), w, self.e_dose.get(), c, self.e_det.get(), self.e_admin.get(), self.img_path)
        self.cb(self.selection_key)
        self.destroy()

class BatchHealthPopup(ctk.CTkToplevel):
    def __init__(self, controller, refresh_cb):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.refresh_cb = refresh_cb
        self.title("Batch Health Event")
        self.geometry("500x800")
        self.lift(); self.focus_force(); self.grab_set()
        
        self.scroll = ctk.CTkScrollableFrame(self, width=500, height=800)
        self.scroll.pack(fill="both", expand=True)

        ctk.CTkLabel(self.scroll, text="Batch Entry Details", font=ctk.CTkFont(size=16, weight="bold")).pack(pady=10)
        ctk.CTkLabel(self.scroll, text="Event Type").pack()
        self.c_type = ctk.CTkComboBox(self.scroll, values=["Vaccination", "Deworming", "Hoof Trim", "Weight Check"])
        self.c_type.pack()
        
        self.e_date = self.entry("Date", datetime.now().strftime("%Y-%m-%d"))
        self.e_dose = self.entry("Dosage (Per Goat)")
        self.e_cost = self.entry("Cost (Per Goat)")
        self.e_admin = self.entry("Performed By")
        self.e_det = self.entry("Details")

        self.v_sched = ctk.IntVar()
        ctk.CTkCheckBox(self.scroll, text="Schedule Follow-up", variable=self.v_sched, command=self.toggle_sched).pack(pady=10)
        self.f_sched = ctk.CTkFrame(self.scroll)
        self.e_dose_num = self.entry_in(self.f_sched, "Dose #")
        self.e_total = self.entry_in(self.f_sched, "Total")
        self.e_qty = self.entry_in(self.f_sched, "Next In")
        self.c_unit = ctk.CTkComboBox(self.f_sched, values=["Days", "Weeks", "Months"]); self.c_unit.pack()
        self.c_unit.set("Days")

        ctk.CTkLabel(self.scroll, text="Select Goats", font=ctk.CTkFont(size=16, weight="bold")).pack(pady=(20,10))
        self.var_all = ctk.IntVar()
        ctk.CTkCheckBox(self.scroll, text="SELECT ALL", variable=self.var_all, command=self.toggle_all).pack(anchor="w", padx=20)
        
        self.check_vars = {} 
        goats = self.controller.db.fetch_active_goats()
        
        self.f_list = ctk.CTkFrame(self.scroll)
        self.f_list.pack(fill="x", padx=10)
        
        for g in goats:
            var = ctk.IntVar()
            self.check_vars[g['id']] = var
            ctk.CTkCheckBox(self.f_list, text=f"{g['name']} ({g['tag_number']})", variable=var).pack(anchor="w", pady=2)

        ctk.CTkButton(self.scroll, text="SAVE BATCH", fg_color="green", height=50, command=self.save).pack(pady=30)

    def toggle_all(self):
        val = self.var_all.get()
        for v in self.check_vars.values(): v.set(val)

    def toggle_sched(self):
        if self.v_sched.get(): self.f_sched.pack(fill='x', padx=20)
        else: self.f_sched.pack_forget()

    def entry(self, txt, val=""):
        ctk.CTkLabel(self.scroll, text=txt).pack(pady=(5,0)); e = ctk.CTkEntry(self.scroll); e.pack(); 
        if val: e.insert(0, val)
        return e
    
    def entry_in(self, parent, txt):
        ctk.CTkLabel(parent, text=txt).pack(pady=(2,0)); e = ctk.CTkEntry(parent); e.pack(); return e

    def save(self):
        ids_to_process = [gid for gid, var in self.check_vars.items() if var.get() == 1]
        if not ids_to_process:
            messagebox.showwarning("Warning", "No goats selected.")
            return

        c_val = float(self.e_cost.get()) if self.e_cost.get() else 0.0
        
        follow_up = None
        t_num, t_tot = 1, 1
        if self.v_sched.get():
            try:
                t_num = int(self.e_dose_num.get())
                t_tot = int(self.e_total.get())
                qty = int(self.e_qty.get())
                unit = self.c_unit.get()
                now = datetime.strptime(self.e_date.get(), "%Y-%m-%d")
                delta = timedelta(days=qty)
                if unit == "Weeks": delta = timedelta(weeks=qty)
                elif unit == "Months": delta = timedelta(days=qty*30)
                follow_up = (now + delta).strftime("%Y-%m-%d")
            except: pass

        count = 0
        for gid in ids_to_process:
            self.controller.db.add_health_event(
                gid, self.e_date.get(), self.c_type.get(), 0.0, 
                self.e_dose.get(), c_val, self.e_det.get(), 
                self.e_admin.get(), t_num, t_tot, follow_up
            )
            count += 1
        
        messagebox.showinfo("Success", f"Added records for {count} goats.")
        self.refresh_cb()
        self.destroy()

class BreedingPopup(ctk.CTkToplevel):
    def __init__(self, controller, cb, rec_id=None):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.cb = cb
        self.rec_id = rec_id
        self.title("Log Breeding")
        self.geometry("300x300")
        self.lift(); self.focus_force(); self.grab_set()

        ctk.CTkLabel(self, text="Doe").pack()
        self.c_doe = ctk.CTkComboBox(self, values=self.get_list("Doe"))
        self.c_doe.pack()
        ctk.CTkLabel(self, text="Buck").pack()
        self.c_buck = ctk.CTkComboBox(self, values=self.get_list("Buck"))
        self.c_buck.pack()
        self.e_date = ctk.CTkEntry(self); self.e_date.pack(pady=10)
        self.e_date.insert(0, datetime.now().strftime("%Y-%m-%d"))
        if rec_id:
            r = self.controller.db.fetch_breeding_record_by_id(rec_id)
            self.set_combo(self.c_doe, r['doe_id'])
            self.set_combo(self.c_buck, r['buck_id'])
            self.e_date.delete(0,'end'); self.e_date.insert(0, r['breeding_date'])
        ctk.CTkButton(self, text="SAVE", command=self.save).pack(pady=10)
    def get_list(self, sex):
        rows = self.controller.db.fetch_active_goats(sex)
        lst = [f"{r['name']} ({r['tag_number']}) [{r['id']}]" for r in rows]
        lst.insert(0, "Unknown [None]")
        return lst
    def set_combo(self, combo, tid):
        for v in combo._values:
            if v.endswith(f"[{tid}]"): combo.set(v); break
    def save(self):
        did = self.c_doe.get().split('[')[1].strip(']') if self.c_doe.get() else None
        bid = self.c_buck.get().split('[')[1].strip(']') if self.c_buck.get() else None
        dt = self.e_date.get()
        due = (datetime.strptime(dt, "%Y-%m-%d") + timedelta(days=145)).strftime("%Y-%m-%d")
        if self.rec_id:
            self.controller.db.update_breeding_record(self.rec_id, did, bid, dt, due)
        else:
            self.controller.db.add_breeding(did, bid, dt, due)
        self.cb()
        self.destroy()

class BreedingStatusPopup(ctk.CTkToplevel):
    def __init__(self, controller, rec_id, cb):
        super().__init__()
        self.attributes("-topmost", True)
        self.db = controller.db
        self.rec_id = rec_id
        self.cb = cb
        self.geometry("300x200")
        self.lift(); self.focus_force(); self.grab_set()

        self.v_heat = ctk.IntVar()
        self.v_scan = ctk.IntVar()
        ctk.CTkCheckBox(self, text="Heat Check Passed", variable=self.v_heat).pack(pady=10)
        ctk.CTkCheckBox(self, text="Scan Confirmed", variable=self.v_scan).pack(pady=10)
        ctk.CTkButton(self, text="UPDATE", command=self.save).pack(pady=10)
    def save(self):
        self.db.update_breeding_status(self.rec_id, self.v_heat.get(), self.v_scan.get())
        self.cb()
        self.destroy()

class KiddingPopup(ctk.CTkToplevel):
    def __init__(self, controller, rec_id, cb):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.rec_id = rec_id
        self.cb = cb
        self.title("Kidding")
        self.geometry("300x250")
        self.lift(); self.focus_force(); self.grab_set()

        rec = self.controller.db.fetch_breeding_record_by_id(rec_id)
        self.dam_id = rec['doe_id']
        self.sire_id = rec['buck_id']
        ctk.CTkLabel(self, text="Date").pack()
        self.e_date = ctk.CTkEntry(self); self.e_date.pack()
        self.e_date.insert(0, datetime.now().strftime("%Y-%m-%d"))
        ctk.CTkLabel(self, text="Count").pack()
        self.e_count = ctk.CTkEntry(self); self.e_count.pack()
        ctk.CTkButton(self, text="SAVE", command=self.save).pack(pady=20)
    def save(self):
        dt = self.e_date.get()
        cnt = self.e_count.get()
        if self.controller.db.update_kidding(self.rec_id, dt, cnt):
            self.cb()
            self.destroy()
            for i in range(int(cnt)):
                w = AddGoatPopup(self.controller, self.cb, pre_dob=dt, pre_dam=self.dam_id, pre_sire=self.sire_id, title=f"Kid {i+1}")
                self.controller.wait_window(w)

class ArchivePopup(ctk.CTkToplevel):
    def __init__(self, controller, goat_id, cb):
        super().__init__()
        self.attributes("-topmost", True)
        self.db = controller.db
        self.gid = goat_id
        self.cb = cb
        self.geometry("300x300")
        self.lift(); self.focus_force(); self.grab_set()

        ctk.CTkLabel(self, text="Reason").pack()
        self.c_res = ctk.CTkComboBox(self, values=["Sold", "Died"])
        self.c_res.pack()
        ctk.CTkLabel(self, text="Date").pack()
        self.e_date = ctk.CTkEntry(self); self.e_date.pack()
        self.e_date.insert(0, datetime.now().strftime("%Y-%m-%d"))
        ctk.CTkLabel(self, text="Final Weight").pack()
        self.e_wgt = ctk.CTkEntry(self); self.e_wgt.pack()
        ctk.CTkLabel(self, text="Notes/Price").pack()
        self.e_note = ctk.CTkEntry(self); self.e_note.pack()
        ctk.CTkButton(self, text="ARCHIVE", fg_color="red", command=self.save).pack(pady=20)
    def save(self):
        self.db.archive_goat(self.gid, self.c_res.get(), self.e_date.get(), self.e_wgt.get(), self.e_note.get())
        self.cb()
        self.destroy()

class LineagePopup(ctk.CTkToplevel):
    def __init__(self, controller, goat_id):
        super().__init__()
        self.attributes("-topmost", True)
        self.geometry("400x300")
        self.lift(); self.focus_force(); self.grab_set()

        g = controller.db.fetch_goat_details(goat_id)
        t = ctk.CTkTextbox(self)
        t.pack(fill="both", expand=True)
        s_nm = g['sire_name'] if g['sire_name'] else "Unknown"
        s_tg = g['sire_tag'] if g['sire_tag'] else "-"
        d_nm = g['dam_name'] if g['dam_name'] else "Unknown"
        d_tg = g['dam_tag'] if g['dam_tag'] else "-"
        txt = f"""PEDIGREE: {g['name']} ({g['tag_number']})\n{'='*30}\nSIRE: {s_nm} ({s_tg})\nDAM:  {d_nm} ({d_tg})"""
        t.insert("0.0", txt)

class ProfileWindow(ctk.CTkToplevel):
    def __init__(self, controller, goat_id):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.geometry("600x800")
        self.main_scroll = ctk.CTkScrollableFrame(self, width=600, height=800)
        self.main_scroll.pack(fill="both", expand=True)
        self.lift(); self.focus_force(); self.grab_set()
        self.view_profile(goat_id)
    def view_profile(self, goat_id):
        for w in self.main_scroll.winfo_children(): w.destroy()
        g = self.controller.db.fetch_goat_details(goat_id)
        h = ctk.CTkFrame(self.main_scroll); h.pack(fill="x", padx=10, pady=10)
        
        if g['profile_image'] and os.path.exists(g['profile_image']):
             try:
                 img_data = Image.open(g['profile_image'])
                 self.profile_pic = ctk.CTkImage(light_image=img_data, dark_image=img_data, size=(150, 150))
                 lbl_img = ctk.CTkLabel(h, image=self.profile_pic, text="")
                 lbl_img.pack(side="left", padx=10)
                 lbl_img.image = self.profile_pic 
                 lbl_img.bind("<Double-Button-1>", lambda e, p=g['profile_image']: self.open_image(p))
             except: pass
        
        ctk.CTkButton(h, text="📷 Change Photo", width=80, height=30, fg_color="#5c7cfa", command=lambda: self.change_photo(goat_id)).pack(side="left", padx=5)

        ctk.CTkLabel(h, text=f"{g['name']} ({g['tag_number']})", font=ctk.CTkFont(size=24, weight="bold")).pack()
        ctk.CTkLabel(h, text=f"{g['breed']} | {g['sex']} | {g['date_of_birth']}").pack()
        p = ctk.CTkFrame(self.main_scroll); p.pack(fill="x", padx=10, pady=5)
        ctk.CTkLabel(p, text="PARENTS", font=ctk.CTkFont(weight="bold")).pack()
        stxt = f"Sire: {g['sire_name']}" if g['sire_id'] else "Sire: Unknown"
        dtxt = f"Dam: {g['dam_name']}" if g['dam_id'] else "Dam: Unknown"
        if g['sire_id']: ctk.CTkButton(p, text=stxt, command=lambda: self.view_profile(g['sire_id'])).pack(fill="x", pady=2)
        else: ctk.CTkLabel(p, text=stxt).pack()
        if g['dam_id']: ctk.CTkButton(p, text=dtxt, command=lambda: self.view_profile(g['dam_id'])).pack(fill="x", pady=2)
        else: ctk.CTkLabel(p, text=dtxt).pack()
        k = ctk.CTkFrame(self.main_scroll); k.pack(fill="both", padx=10, pady=5)
        ctk.CTkLabel(k, text="OFFSPRING", font=ctk.CTkFont(weight="bold")).pack()
        kids = self.controller.db.fetch_goat_offspring(goat_id)
        if not kids: ctk.CTkLabel(k, text="None").pack()
        for kid in kids:
            age_str = "?"
            try:
                dob = datetime.strptime(kid['date_of_birth'], "%Y-%m-%d")
                d = datetime.now() - dob
                if d.days < 365: age_str = f"{int(d.days/30)}m"
                else: age_str = f"{int(d.days/365)}y"
            except: pass
            ctk.CTkButton(k, text=f"{kid['name']} ({kid['tag_number']}) - {age_str}", fg_color="gray", command=lambda x=kid['id']: self.view_profile(x)).pack(fill="x", pady=2)
        
        f_docs = ctk.CTkFrame(self.main_scroll)
        f_docs.pack(fill='x', padx=10, pady=5)
        ctk.CTkLabel(f_docs, text="DOCUMENTS", font=ctk.CTkFont(weight="bold")).pack(side="left", padx=5)
        ctk.CTkButton(f_docs, text="+ Upload Document", width=120, height=30, command=lambda: self.popup_upload_doc(goat_id)).pack(side="right", padx=5)
        docs = self.controller.db.fetch_documents(goat_id)
        if docs:
            for d in docs:
                row = ctk.CTkFrame(self.main_scroll)
                row.pack(fill='x', padx=20, pady=2)
                ctk.CTkLabel(row, text=f"📄 {d['doc_type']} - {d['notes']}").pack(side="left")
                ctk.CTkButton(row, text="OPEN", width=60, height=25, command=lambda p=d['file_path']: self.open_image(p)).pack(side="right")
                ctk.CTkButton(row, text="X", width=30, fg_color="red", command=lambda did=d['id']: self.delete_doc(did, goat_id)).pack(side="right", padx=2)

        f_med = ctk.CTkFrame(self.main_scroll)
        f_med.pack(fill='both', expand=True, padx=10, pady=5)
        ctk.CTkLabel(f_med, text="MEDICAL HISTORY", font=ctk.CTkFont(weight="bold")).pack(pady=5)
        meds = self.controller.db.fetch_health_history(goat_id)
        for m in meds:
            row = ctk.CTkFrame(f_med)
            row.pack(fill="x", pady=2)
            info = f"{m['event_date']}: {m['event_type']} - {m['details']}"
            lbl = ctk.CTkLabel(row, text=info)
            lbl.pack(side="left", padx=5)
            key_str = f"{g['name']} ({g['tag_number']})"
            lbl.bind("<Double-Button-1>", lambda e, gid=goat_id, eid=m['id'], k=key_str: self.open_edit_health(gid, eid, k))
            if m['image_path']:
                btn_txt = "VIEW PDF" if m['image_path'].lower().endswith('.pdf') else "VIEW IMAGE"
                ctk.CTkButton(row, text=btn_txt, width=80, fg_color="#E04F5F", command=lambda p=m['image_path']: self.open_image(p)).pack(side="right")

    def delete_doc(self, doc_id, goat_id):
        if messagebox.askyesno("Confirm", "Delete this document?"):
            self.controller.db.delete_document(doc_id)
            self.view_profile(goat_id)

    def change_photo(self, goat_id):
        path = filedialog.askopenfilename(filetypes=[("Images", "*.png;*.jpg;*.jpeg")])
        if path:
            dest = os.path.join(UPLOAD_DIR, os.path.basename(path))
            shutil.copy(path, dest)
            self.controller.db.update_goat_photo(goat_id, dest)
            self.view_profile(goat_id) 

    def popup_upload_doc(self, goat_id):
        AddDocumentPopup(self.controller, goat_id, lambda: self.view_profile(goat_id))

    def open_edit_health(self, goat_id, event_id, key_str):
        def dummy_cb(x): self.view_profile(goat_id)
        EditHealthPopup(self.controller, goat_id, dummy_cb, key_str, event_id)

    def open_image(self, path):
        try:
            if platform.system() == 'Windows': os.startfile(path)
            elif platform.system() == 'Darwin': subprocess.call(('open', path))
            else: subprocess.call(('xdg-open', path))
        except: messagebox.showerror("Error", "Could not open file.")

class AddDocumentPopup(ctk.CTkToplevel):
    def __init__(self, controller, goat_id, cb):
        super().__init__()
        self.attributes("-topmost", True)
        self.controller = controller
        self.goat_id = goat_id
        self.cb = cb
        self.title("Upload Document")
        self.geometry("400x400")
        self.lift(); self.focus_force(); self.grab_set()
        
        self.file_path = None
        ctk.CTkButton(self, text="Select File (PDF/Image/Doc)", command=self.select_file).pack(pady=20)
        self.lbl_file = ctk.CTkLabel(self, text="No file selected", text_color="gray")
        self.lbl_file.pack()
        
        ctk.CTkLabel(self, text="Document Type").pack(pady=(10,0))
        self.c_type = ctk.CTkComboBox(self, values=["Pedigree", "Registration", "Medical Record", "Bill of Sale", "Other"])
        self.c_type.pack()
        
        ctk.CTkLabel(self, text="Notes").pack(pady=(10,0))
        self.e_note = ctk.CTkEntry(self)
        self.e_note.pack()
        
        ctk.CTkButton(self, text="UPLOAD", fg_color="green", command=self.save).pack(pady=20)

    def select_file(self):
        path = filedialog.askopenfilename(filetypes=[("Documents", "*.pdf;*.jpg;*.png;*.docx;*.txt")])
        if path:
            self.file_path = path
            self.lbl_file.configure(text=os.path.basename(path), text_color="#2cc985")

    def save(self):
        if not self.file_path: return
        dest = os.path.join(UPLOAD_DIR, os.path.basename(self.file_path))
        shutil.copy(self.file_path, dest)
        self.controller.db.add_document(self.goat_id, dest, self.c_type.get(), self.e_note.get())
        self.cb()
        self.destroy()

if __name__ == "__main__":
    app = ModernGoatGUI()
    app.mainloop()