console_app.py

# console_app.py

from datetime import datetime
from cleaning_agent import CleaningAgent
from extraction_agent import ExtractionAgent
from indexing_agent import IndexingAgent
from session_state import SessionState
from memory_store import save_incident_to_memory, save_feedback_to_memory, load_all_incidents
from context_utils import build_compact_summary
import os


def generate_report_id() -> str:
    """Create an ID like IR_20251129_173055."""
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    return f"IR_{ts}", ts


def format_report(report_id: str,
                  created_at: str,
                  description: str,
                  case) -> str:
    """
    Build a nicely formatted incident report as a text block.
    `case` is an ExtractedCase from ExtractionAgent.
    """
    perpetrators = ", ".join(case.entities.get("perpetrators") or []) or "None"
    locations    = ", ".join(case.entities.get("locations") or []) or "None"
    violations   = ", ".join(case.entities.get("violations") or []) or "None"

    lines = []
    lines.append("=" * 60)
    lines.append(f"Incident Report ID: {report_id}")
    lines.append(f"Created At: {created_at}")
    lines.append("")
    lines.append("Original Description")
    lines.append("--------------------")
    lines.append(description.strip())
    lines.append("")
    lines.append("Cleaned Summary")
    lines.append("----------------")
    lines.append(case.summary.strip())
    lines.append("")
    lines.append("Entities")
    lines.append("--------")
    lines.append(f"Perpetrators : {perpetrators}")
    lines.append(f"Locations    : {locations}")
    lines.append(f"Violations   : {violations}")
    lines.append("=" * 60)

    return "\n".join(lines)


def save_report_to_file(report_id: str, report_text: str, folder: str = "generated_reports"):
    """
    Optional: save each report as a text file.
    Creates folder `generated_reports/` if it does not exist.
    """
    if not os.path.exists(folder):
        os.makedirs(folder)

    filename = os.path.join(folder, f"{report_id}.txt")
    with open(filename, "w", encoding="utf-8") as f:
        f.write(report_text)

    print(f"[Saved] {filename}")


def log_feedback(report_id: str,
                 description: str,
                 case,
                 category: str,
                 user_note: str,
                 feedback_file: str = "customer_feedback.txt"):
    """
    Append a feedback record to customer_feedback.txt.
    Includes timestamp, report_id, category, user note, and current entities.
    """
    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    perpetrators = ", ".join(case.entities.get("perpetrators") or []) or "None"
    locations    = ", ".join(case.entities.get("locations") or []) or "None"
    violations   = ", ".join(case.entities.get("violations") or []) or "None"

    with open(feedback_file, "a", encoding="utf-8") as f:
        f.write("\n" + "#" * 70 + "\n")
        f.write(f"Feedback Timestamp : {ts}\n")
        f.write(f"Report ID          : {report_id}\n")
        f.write(f"Category           : {category}\n")
        f.write(f"User Feedback      : {user_note.strip()}\n")
        f.write("\n")
        f.write("Original Description:\n")
        f.write(description.strip() + "\n\n")
        f.write("Current Extracted Entities:\n")
        f.write(f"  Perpetrators : {perpetrators}\n")
        f.write(f"  Locations    : {locations}\n")
        f.write(f"  Violations   : {violations}\n")
        f.write("#" * 70 + "\n")

    print(f"[Feedback logged] ({category}) → {feedback_file}")


def run_console():
    cleaner   = CleaningAgent()
    extractor = ExtractionAgent()
    indexer   = IndexingAgent()

    session_id = datetime.now().strftime("SESSION_%Y%m%d_%H%M%S")
    session = SessionState(
        session_id=session_id,
        started_at=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
    )

    print("=== Incident Helper Console ===")
    print("Available commands: history, last, today, exit\n")
    print(f"(Session: {session_id})")
    print("Type an incident description and press Enter.")
    print("Type 'exit' to quit.\n")

    while True:
        print("\n Commands: history = show all the incidents,last = show previous incident, today = list today's incidents, exit = quit \n")
        description = input("Describe incident or enter a command: ").strip()

        #Context Engineering
        if description.lower() == "context":
          print("\n=== COMPACT CONTEXT BLOCK (last 5 incidents) ===")
          from context_utils import build_compact_context
          ctx = build_compact_context(session, limit=5)
          print(ctx)
          print()
          continue

        # Memory Bank
        if description.lower() == "history":
          all_incidents = load_all_incidents()
          if not all_incidents:
              print("No incidents in long-term memory yet.\n")
          else:
              print("\n=== ALL INCIDENTS (LONG-TERM) ===")
              for inc in all_incidents[-20:]: #for demo purpose , we will show only 20 incidents
                  print(f"- {inc.created_at} | {inc.report_id} | {inc.description}")
              print()
          continue

        # Exit command
        if description.lower() == "exit":
            print("Goodbye!")
            break
        
        # Session Show all incidents for today
        if description.lower() == "today":
            today_list = session.incidents_today()
            if not today_list:
                print("\nNo incidents created today.\n")
                continue

            print("\n=== INCIDENTS CREATED TODAY ===")
            for inc in today_list:
                print(f"- {inc.report_id} | {inc.created_at} | Desc: {inc.description[:40]}...")
            print()
            continue

        # Last incident in this session
        if description.lower() == "last":
            last = session.last_incident()
            if not last:
                print("\nNo incidents in this session yet.\n")
                continue

            print("\n=== LAST INCIDENT THIS SESSION ===")
            print(f"Report ID : {last.report_id}")
            print(f"Created   : {last.created_at}")
            print(f"Desc      : {last.description}")
            print(f"Perp      : {', '.join(last.case.entities.get('perpetrators') or []) or 'None'}")
            print()
            continue

        if not description:
            print("Please enter some text.\n")
            continue
        
        word_count = len(description.split())
        if word_count < 3:
            print("Description too short. Please enter at least 3 meaningful words.\n")
            continue

        # 1) Generate report ID with timestamp
        report_id, ts_str = generate_report_id()

        # 2) Cleaning
        clean_result = cleaner.clean(description)

        compact = build_compact_summary(description, clean_result.tokens)

        # 3) Extraction (LLM)
        case = extractor.extract(report_id, description, clean_result.tokens)

        # 4) Add to index
        indexer.add_case(case)

        # 5) Store in session state
        session.add_incident(report_id, description, case,compact)
        session_incident = session.last_incident()
        save_incident_to_memory(session_incident)
        with open("long_term_memory.txt", "a", encoding="utf-8") as f:
          inc = session.last_incident()
          f.write(f"{inc.created_at} | {inc.report_id} | {inc.compact}\n")

        # 6) Build formatted report text
        created_at_human = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        report_text = format_report(
            report_id=report_id,
            created_at=created_at_human,
            description=description,
            case=case,
        )

        # 7) Print to console
        print()
        print(report_text)
        print()

        # 8) Save to file?
        save_choice = input("Save this report to file? (y/n): ").strip().lower()
        if save_choice == "y":
            save_report_to_file(report_id, report_text)

        # 9) Feedback
        fb_choice = input("Was anything wrong in the extracted info? (y/n): ").strip().lower()
        if fb_choice == "y":
            print("What was wrong?")
            print("1) Perpetrators")
            print("2) Locations")
            print("3) Violations")
            print("4) Other")

            raw_choices = input("Enter choice(s), e.g. 1,3 or 2,4: ").strip()
            choice_list = [c.strip() for c in raw_choices.split(",") if c.strip()]

            category_map = {
                "1": "perpetrators",
                "2": "locations",
                "3": "violations",
                "4": "other",
            }

            # Collect selected categories
            selected_categories = [category_map[c] for c in choice_list if c in category_map]

            if not selected_categories:
                print("No valid categories selected.\n")
            else:
                category_str = ", ".join(selected_categories)
                print(f"\nYou selected: {category_str}")
                user_note = input(
                    "Please describe what was wrong and (optionally) what it should be:\n> "
                )

                # Log one combined feedback record
                log_feedback(
                    report_id=report_id,
                    description=description,
                    case=case,
                    category=category_str,
                    user_note=user_note,
                )

                # Also store a lightweight note in session state
                session.add_feedback(
                    report_id=report_id,
                    categories=selected_categories,
                    user_note="(See feedback file for details)",
                )
                last_fb = session.feedback[-1]
                save_feedback_to_memory(last_fb)

            print()


if __name__ == "__main__":
    run_console()