Update app.py

app.py

@@ -1,6 +1,7 @@
 import os
 import time
 import hashlib
+import json
 from dotenv import load_dotenv
 import streamlit as st
 from langchain_community.vectorstores import FAISS
@@ -74,6 +75,22 @@ st.markdown("""
         max-width: 250px;
         height: auto;
     }
+    .judge-badge {
+        background-color: #991b1b;
+        color: white;
+        padding: 5px 10px;
+        border-radius: 12px;
+        font-weight: 600;
+        display: inline-block;
+        margin-bottom: 10px;
+    }
+    .judgment-card {
+        background-color: #1e293b;
+        border-radius: 8px;
+        padding: 20px;
+        margin-bottom: 20px;
+        border-left: 4px solid #991b1b;
+    }
     </style>
 """, unsafe_allow_html=True)
 
@@ -90,9 +107,9 @@ if "authenticated" not in st.session_state:
 
 if st.session_state.role is None:
     st.markdown("<h2 style='text-align: center;'>Who are you?</h2>", unsafe_allow_html=True)
-    col1, col2, col3 = st.columns([1, 2, 1])
+    col1, col2, col3 = st.columns([1, 3, 1])
     with col2:
-        col_a, col_b = st.columns(2)
+        col_a, col_b, col_c = st.columns(3)
         with col_a:
             if st.button("🧑 I am a Civilian"):
                 st.session_state.role = "civilian"
@@ -102,9 +119,13 @@ if st.session_state.role is None:
             if st.button("⚖️ I am a Court Stakeholder"):
                 st.session_state.role = "stakeholder"
                 st.rerun()
+        with col_c:
+            if st.button("👨‍⚖️ I am a Judge"):
+                st.session_state.role = "judge"
+                st.rerun()
 
-if st.session_state.role == "stakeholder" and not st.session_state.authenticated:
-    st.markdown("### 🔐 Stakeholder Login")
+if (st.session_state.role == "stakeholder" or st.session_state.role == "judge") and not st.session_state.authenticated:
+    st.markdown(f"### 🔐 {'Judge' if st.session_state.role == 'judge' else 'Stakeholder'} Login")
     username = st.text_input("Username")
     password = st.text_input("Password", type="password")
     if st.button("Login"):
@@ -122,16 +143,37 @@ if st.session_state.role and (st.session_state.role == "civilian" or st.session_
         st.rerun()
 
     tabs = ["📘 LawGPT"]
-    if st.session_state.role == "stakeholder":
+    
+    if st.session_state.role == "judge":
+        tabs.extend(["👨‍⚖️ Judge Console", "📜 Previous Judgments"])
+    elif st.session_state.role == "stakeholder":
         tabs.extend(["📝 Document Signer", "🔍 Verify Document"])
 
     selected_tab = st.tabs(tabs)
 
+    # Load embeddings and DB for all roles
+    embeddings = HuggingFaceEmbeddings(
+        model_name="nomic-ai/nomic-embed-text-v1",
+        model_kwargs={"trust_remote_code": True, "revision": "289f532e14dbbbd5a04753fa58739e9ba766f3c7"}
+    )
+
+    db = FAISS.load_local("ipc_vector_db", embeddings, allow_dangerous_deserialization=True)
+    db_retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": 4})
+
+    # Common LLM setup
+    llm = Together(
+        model="mistralai/Mistral-7B-Instruct-v0.2",
+        temperature=0.5,
+        max_tokens=1024,
+        together_api_key=os.getenv("TOGETHER_API_KEY")
+    )
+
+    # LawGPT Tab for all roles
     if "📘 LawGPT" in tabs:
         with selected_tab[0]:
             st.markdown("## 💬  Your Legal AI Lawyer")
             st.markdown("### Ask any legal question related to the Indian Penal Code (IPC)")
-            st.markdown("Questions might be of types like: Suppose a 16 year old is  drinking and driving , and hit a pedestrian on the road . what are the possible case laws imposed and give any one previous court decisions on the same.  ")
+            st.markdown("Questions might be of types like: Suppose a 16 year old is drinking and driving, and hit a pedestrian on the road. What are the possible case laws imposed and give any one previous court decisions on the same.")
 
             def reset_conversation():
                 st.session_state.messages = []
@@ -144,14 +186,6 @@ if st.session_state.role and (st.session_state.role == "civilian" or st.session_
                     k=2, memory_key="chat_history", return_messages=True
                 )
 
-            embeddings = HuggingFaceEmbeddings(
-                model_name="nomic-ai/nomic-embed-text-v1",
-                model_kwargs={"trust_remote_code": True, "revision": "289f532e14dbbbd5a04753fa58739e9ba766f3c7"}
-            )
-
-            db = FAISS.load_local("ipc_vector_db", embeddings, allow_dangerous_deserialization=True)
-            db_retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": 4})
-
             prompt_template = """<s>[INST]You are a legal chatbot that answers questions about the Indian Penal Code (IPC).
 Provide clear, concise, and accurate responses based on context and user's question.
 Avoid extra details or assumptions. Focus only on legal information.
@@ -168,13 +202,6 @@ ANSWER:
                 input_variables=["context", "question", "chat_history"]
             )
 
-            llm = Together(
-                model="mistralai/Mistral-7B-Instruct-v0.2",
-                temperature=0.5,
-                max_tokens=1024,
-                together_api_key=os.getenv("TOGETHER_API_KEY")
-            )
-
             qa = ConversationalRetrievalChain.from_llm(
                 llm=llm,
                 memory=st.session_state.memory,
@@ -206,10 +233,408 @@ ANSWER:
                             full_response += chunk
                             time.sleep(0.02)
                             message_placeholder.markdown(full_response + " ▌")
+                    message_placeholder.markdown(full_response)
                 st.session_state.messages.append({"role": "assistant", "content": result["answer"]})
 
             st.button("🔄 Reset Chat", on_click=reset_conversation)
 
+    # Judge Console Tab
+    if st.session_state.role == "judge":
+        # Initialize judgment storage
+        if "judgments" not in st.session_state:
+            st.session_state.judgments = []
+            
+            # Load existing judgments if file exists
+            try:
+                with open("judgments.json", "r") as f:
+                    st.session_state.judgments = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                pass
+        
+        with selected_tab[1]:
+            st.markdown("## 👨‍⚖️ Judge's Decision Console")
+            st.markdown("### Enter case details for analysis and judgment")
+            
+            # Input fields for case details
+            st.subheader("Case Information")
+            case_number = st.text_input("Case Number/ID")
+            case_title = st.text_input("Case Title")
+            plaintiff = st.text_input("Plaintiff/Prosecution")
+            defendant = st.text_input("Defendant/Accused")
+            
+            # Case facts and context
+            st.subheader("Case Details")
+            case_facts = st.text_area("Enter detailed facts of the case:", height=200)
+            
+            # Get relevant laws/sections that apply
+            relevant_laws = st.text_area("Relevant IPC Sections (if known):", 
+                                         placeholder="e.g. Section 302, Section 376, etc.")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                case_type = st.selectbox("Case Type", [
+                    "Criminal", "Civil", "Family", "Property", "Cyber Crime", 
+                    "Corporate", "Intellectual Property", "Other"
+                ])
+            with col2:
+                case_priority = st.select_slider("Case Priority", 
+                                                options=["Low", "Medium", "High", "Urgent"])
+            
+            if st.button("Generate Judgment"):
+                if not case_facts:
+                    st.error("Please enter the case facts to generate a judgment.")
+                else:
+                    with st.status("Analyzing case and formulating judgment...", expanded=True):
+                        # Create a prompt for legal judgment
+                        judge_prompt_template = """<s>[INST]You are an experienced Indian judge making a legal judgment based on the Indian Penal Code (IPC).
+Review the case details and provide a comprehensive legal judgment.
+
+CASE NUMBER: {case_number}
+CASE TITLE: {case_title}
+PLAINTIFF/PROSECUTION: {plaintiff}
+DEFENDANT/ACCUSED: {defendant}
+CASE TYPE: {case_type}
+CASE FACTS: {case_facts}
+RELEVANT IPC SECTIONS: {relevant_laws}
+
+Your judgment should follow this structure:
+1. Summary of the case
+2. Facts of the case
+3. Legal issues involved
+4. Analysis of applicable laws and precedents
+5. Reasoning and findings
+6. Final judgment and orders
+7. Any remedies or penalties imposed
+
+Be impartial, consider only facts and relevant laws, and make a fair judgment.
+</s>[INST]"""
+
+                        judge_prompt = PromptTemplate(
+                            template=judge_prompt_template,
+                            input_variables=["case_number", "case_title", "plaintiff", "defendant", 
+                                             "case_type", "case_facts", "relevant_laws"]
+                        )
+                        
+                        # Format prompt with case details
+                        formatted_prompt = judge_prompt.format(
+                            case_number=case_number if case_number else "Unassigned",
+                            case_title=case_title if case_title else "Unnamed Case",
+                            plaintiff=plaintiff if plaintiff else "Unspecified",
+                            defendant=defendant if defendant else "Unspecified",
+                            case_type=case_type,
+                            case_facts=case_facts,
+                            relevant_laws=relevant_laws if relevant_laws else "To be determined"
+                        )
+                        
+                        # Generate judgment using LLM
+                        judgment_result = llm.invoke(formatted_prompt)
+                        
+                        # Save judgment to session state
+                        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+                        judgment_data = {
+                            "id": hashlib.md5(f"{case_title}{timestamp}".encode()).hexdigest()[:8],
+                            "case_number": case_number if case_number else "Unassigned",
+                            "case_title": case_title if case_title else "Unnamed Case",
+                            "plaintiff": plaintiff,
+                            "defendant": defendant,
+                            "case_type": case_type,
+                            "priority": case_priority,
+                            "facts": case_facts,
+                            "relevant_laws": relevant_laws,
+                            "judgment": judgment_result,
+                            "timestamp": timestamp
+                        }
+                        
+                        st.session_state.judgments.append(judgment_data)
+                        
+                        # Save judgments to file
+                        with open("judgments.json", "w") as f:
+                            json.dump(st.session_state.judgments, f)
+                        
+                    # Display the judgment
+                    st.markdown("### Judgment Generated")
+                    with st.container():
+                        st.markdown(f"<div class='judgment-card'>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='judge-badge'>JUDGMENT #{judgment_data['id']}</div>", unsafe_allow_html=True)
+                        st.markdown(f"**Case**: {judgment_data['case_title']}")
+                        st.markdown(f"**Date**: {judgment_data['timestamp']}")
+                        st.markdown("---")
+                        st.markdown(judgment_data['judgment'])
+                        st.markdown("</div>", unsafe_allow_html=True)
+                    
+                    # Download judgment as PDF
+                    if st.button("📥 Download Judgment as PDF"):
+                        # Generate PDF with ReportLab
+                        pdf_buffer = BytesIO()
+                        c = canvas.Canvas(pdf_buffer, pagesize=letter)
+                        width, height = letter
+                        
+                        # Header
+                        c.setFont("Helvetica-Bold", 16)
+                        c.drawString(72, height - 72, f"JUDGMENT #{judgment_data['id']}")
+                        
+                        # Case details
+                        c.setFont("Helvetica-Bold", 12)
+                        c.drawString(72, height - 100, f"Case: {judgment_data['case_title']}")
+                        c.setFont("Helvetica", 10)
+                        c.drawString(72, height - 115, f"Case Number: {judgment_data['case_number']}")
+                        c.drawString(72, height - 130, f"Date: {judgment_data['timestamp']}")
+                        c.drawString(72, height - 145, f"Plaintiff/Prosecution: {judgment_data['plaintiff']}")
+                        c.drawString(72, height - 160, f"Defendant/Accused: {judgment_data['defendant']}")
+                        c.drawString(72, height - 175, f"Case Type: {judgment_data['case_type']}")
+                        
+                        # Line separator
+                        c.line(72, height - 190, width - 72, height - 190)
+                        
+                        # Format judgment text
+                        judgment_text = judgment_data['judgment']
+                        text_object = c.beginText(72, height - 210)
+                        text_object.setFont("Times-Roman", 10)
+                        
+                        # Wrap text to fit page
+                        lines = []
+                        for paragraph in judgment_text.split('\n\n'):
+                            # Replace single newlines with spaces for proper wrapping
+                            paragraph = paragraph.replace('\n', ' ')
+                            
+                            # Simple word wrap
+                            words = paragraph.split()
+                            line = ''
+                            for word in words:
+                                if len(line + ' ' + word) <= 90:  # character limit per line
+                                    line += ' ' + word if line else word
+                                else:
+                                    lines.append(line)
+                                    line = word
+                            if line:
+                                lines.append(line)
+                            
+                            # Add blank line between paragraphs
+                            lines.append('')
+                        
+                        # Add lines to text object with pagination
+                        line_height = 12
+                        lines_per_page = 50
+                        current_line = 0
+                        
+                        for line in lines:
+                            if current_line >= lines_per_page:
+                                c.drawText(text_object)
+                                c.showPage()
+                                text_object = c.beginText(72, height - 72)
+                                text_object.setFont("Times-Roman", 10)
+                                current_line = 0
+                            
+                            text_object.textLine(line)
+                            current_line += 1
+                        
+                        c.drawText(text_object)
+                        
+                        # Add footer with page numbers
+                        c.saveState()
+                        c.setFont("Helvetica", 8)
+                        c.drawString(width/2 - 40, 30, f"Generated by LawGPT Judge")
+                        c.restoreState()
+                        
+                        # Final page with signature
+                        c.showPage()
+                        c.setFont("Helvetica-Bold", 12)
+                        c.drawString(72, height - 100, "OFFICIAL JUDGMENT")
+                        c.setFont("Helvetica", 10)
+                        c.drawString(72, height - 130, f"Case #{judgment_data['id']} - {judgment_data['case_title']}")
+                        c.drawString(72, height - 150, f"Date: {judgment_data['timestamp']}")
+                        
+                        # Add barcode for authenticity
+                        barcode = code128.Code128(f"JUDGMENT-{judgment_data['id']}", barHeight=10 * mm, barWidth=0.4)
+                        barcode.drawOn(c, 72, 100)
+                        
+                        # Add signature line
+                        c.line(width - 200, 70, width - 72, 70)
+                        c.drawString(width - 180, 60, "Judge's Signature")
+                        
+                        c.save()
+                        
+                        pdf_buffer.seek(0)
+                        
+                        # Offer download
+                        st.download_button(
+                            label="📥 Download Generated PDF",
+                            data=pdf_buffer,
+                            file_name=f"judgment_{judgment_data['id']}_{judgment_data['case_title'].replace(' ', '_')}.pdf",
+                            mime="application/pdf"
+                        )
+                        
+                    st.success("Judgment has been saved to the system.")
+        
+        # Previous Judgments Tab
+        with selected_tab[2]:
+            st.markdown("## 📜 Previous Judgments")
+            st.markdown("### Review and search past judgments")
+            
+            # Search and filter
+            search_term = st.text_input("Search judgments:", placeholder="Enter case title, number, plaintiff, etc.")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                filter_type = st.multiselect("Filter by case type:", 
+                                           options=["All"] + ["Criminal", "Civil", "Family", "Property", "Cyber Crime", 
+                                                   "Corporate", "Intellectual Property", "Other"],
+                                           default=["All"])
+            with col2:
+                sort_by = st.selectbox("Sort by:", options=["Most recent", "Oldest first", "Case title (A-Z)"])
+            
+            # Display judgments based on filters
+            if len(st.session_state.judgments) == 0:
+                st.info("No judgments recorded yet. Use the Judge Console to create judgments.")
+            else:
+                # Filter judgments
+                filtered_judgments = st.session_state.judgments
+                
+                # Apply search term filter
+                if search_term:
+                    filtered_judgments = [j for j in filtered_judgments if 
+                                         search_term.lower() in j['case_title'].lower() or
+                                         search_term.lower() in j['case_number'].lower() or
+                                         search_term.lower() in j['plaintiff'].lower() or
+                                         search_term.lower() in j['defendant'].lower() or
+                                         search_term.lower() in j.get('relevant_laws', '').lower()]
+                
+                # Apply case type filter
+                if "All" not in filter_type:
+                    filtered_judgments = [j for j in filtered_judgments if j['case_type'] in filter_type]
+                
+                # Apply sorting
+                if sort_by == "Most recent":
+                    filtered_judgments = sorted(filtered_judgments, key=lambda x: x['timestamp'], reverse=True)
+                elif sort_by == "Oldest first":
+                    filtered_judgments = sorted(filtered_judgments, key=lambda x: x['timestamp'])
+                elif sort_by == "Case title (A-Z)":
+                    filtered_judgments = sorted(filtered_judgments, key=lambda x: x['case_title'])
+                
+                # Display judgments
+                for judgment in filtered_judgments:
+                    with st.expander(f"**{judgment['case_title']}** - {judgment['timestamp']}"):
+                        st.markdown(f"<div class='judge-badge'>JUDGMENT #{judgment['id']}</div>", unsafe_allow_html=True)
+                        st.markdown(f"**Case Number**: {judgment['case_number']}")
+                        st.markdown(f"**Plaintiff**: {judgment['plaintiff']}")
+                        st.markdown(f"**Defendant**: {judgment['defendant']}")
+                        st.markdown(f"**Case Type**: {judgment['case_type']} (Priority: {judgment['priority']})")
+                        
+                        st.markdown("#### Case Facts")
+                        st.markdown(judgment['facts'])
+                        
+                        if judgment.get('relevant_laws'):
+                            st.markdown("#### Relevant Laws Applied")
+                            st.markdown(judgment['relevant_laws'])
+                        
+                        st.markdown("#### Full Judgment")
+                        st.markdown("---")
+                        st.markdown(judgment['judgment'])
+                        
+                        # Button to download individual judgment as PDF
+                        if st.button(f"📥 Download PDF", key=f"download_{judgment['id']}"):
+                            # Generate PDF with ReportLab
+                            pdf_buffer = BytesIO()
+                            c = canvas.Canvas(pdf_buffer, pagesize=letter)
+                            width, height = letter
+                            
+                            # Header
+                            c.setFont("Helvetica-Bold", 16)
+                            c.drawString(72, height - 72, f"JUDGMENT #{judgment['id']}")
+                            
+                            # Case details
+                            c.setFont("Helvetica-Bold", 12)
+                            c.drawString(72, height - 100, f"Case: {judgment['case_title']}")
+                            c.setFont("Helvetica", 10)
+                            c.drawString(72, height - 115, f"Case Number: {judgment['case_number']}")
+                            c.drawString(72, height - 130, f"Date: {judgment['timestamp']}")
+                            c.drawString(72, height - 145, f"Plaintiff/Prosecution: {judgment['plaintiff']}")
+                            c.drawString(72, height - 160, f"Defendant/Accused: {judgment['defendant']}")
+                            c.drawString(72, height - 175, f"Case Type: {judgment['case_type']}")
+                            
+                            # Line separator
+                            c.line(72, height - 190, width - 72, height - 190)
+                            
+                            # Format judgment text
+                            judgment_text = judgment['judgment']
+                            text_object = c.beginText(72, height - 210)
+                            text_object.setFont("Times-Roman", 10)
+                            
+                            # Wrap text to fit page
+                            lines = []
+                            for paragraph in judgment_text.split('\n\n'):
+                                # Replace single newlines with spaces for proper wrapping
+                                paragraph = paragraph.replace('\n', ' ')
+                                
+                                # Simple word wrap
+                                words = paragraph.split()
+                                line = ''
+                                for word in words:
+                                    if len(line + ' ' + word) <= 90:  # character limit per line
+                                        line += ' ' + word if line else word
+                                    else:
+                                        lines.append(line)
+                                        line = word
+                                if line:
+                                    lines.append(line)
+                                
+                                # Add blank line between paragraphs
+                                lines.append('')
+                            
+                            # Add lines to text object with pagination
+                            line_height = 12
+                            lines_per_page = 50
+                            current_line = 0
+                            
+                            for line in lines:
+                                if current_line >= lines_per_page:
+                                    c.drawText(text_object)
+                                    c.showPage()
+                                    text_object = c.beginText(72, height - 72)
+                                    text_object.setFont("Times-Roman", 10)
+                                    current_line = 0
+                                
+                                text_object.textLine(line)
+                                current_line += 1
+                            
+                            c.drawText(text_object)
+                            
+                            # Add footer with page numbers
+                            c.saveState()
+                            c.setFont("Helvetica", 8)
+                            c.drawString(width/2 - 40, 30, f"Generated by LawGPT Judge")
+                            c.restoreState()
+                            
+                            # Final page with signature
+                            c.showPage()
+                            c.setFont("Helvetica-Bold", 12)
+                            c.drawString(72, height - 100, "OFFICIAL JUDGMENT")
+                            c.setFont("Helvetica", 10)
+                            c.drawString(72, height - 130, f"Case #{judgment['id']} - {judgment['case_title']}")
+                            c.drawString(72, height - 150, f"Date: {judgment['timestamp']}")
+                            
+                            # Add barcode for authenticity
+                            barcode = code128.Code128(f"JUDGMENT-{judgment['id']}", barHeight=10 * mm, barWidth=0.4)
+                            barcode.drawOn(c, 72, 100)
+                            
+                            # Add signature line
+                            c.line(width - 200, 70, width - 72, 70)
+                            c.drawString(width - 180, 60, "Judge's Signature")
+                            
+                            c.save()
+                            
+                            pdf_buffer.seek(0)
+                            
+                            # Offer download
+                            st.download_button(
+                                label="📥 Download Generated PDF",
+                                data=pdf_buffer,
+                                file_name=f"judgment_{judgment['id']}_{judgment['case_title'].replace(' ', '_')}.pdf",
+                                mime="application/pdf",
+                                key=f"pdf_{judgment['id']}"
+                            )
+
+    # Stakeholder tabs
     if st.session_state.role == "stakeholder":
         if "📝 Document Signer" in tabs:
             with selected_tab[1]:
@@ -249,130 +674,130 @@ ANSWER:
             with selected_tab[2]:
                 st.markdown("## 🔍 Verify Document Authentication")
                 st.markdown("Upload any document to verify its integrity and authenticity.")
-        
-        verify_file = st.file_uploader("Upload PDF for verification", type=["pdf"], key="verify")
-        
-        if verify_file:
-            content = verify_file.read()
-            
-            try:
-                # Basic PDF validation
-                pdf = PdfReader(BytesIO(content))
-                
-                # Extract text to look for signature markers
-                all_text = ""
-                for page in pdf.pages:
-                    all_text += page.extract_text() or ""
-                
-                # Check for digital signature information
-                has_signature_text = any(sig_text in all_text.lower() for sig_text in 
-                                         ["signed by:", "digital signature", "electronic signature"])
                 
-                # Create document fingerprint/hash
-                doc_hash = hashlib.sha256(content).hexdigest()
+                verify_file = st.file_uploader("Upload PDF for verification", type=["pdf"], key="verify")
                 
-                # Calculate metadata integrity
-                metadata_valid = True
-                if pdf.metadata:
-                    try:
-                        # Check for suspicious metadata modifications
-                        creation_date = pdf.metadata.get('/CreationDate', '')
-                        mod_date = pdf.metadata.get('/ModDate', '')
-                        if mod_date and creation_date:
-                            metadata_valid = mod_date >= creation_date
-                    except:
-                        metadata_valid = False
-                
-                # Check for content consistency
-                content_consistent = True
-                
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    st.subheader("Document Analysis")
-                    st.info(f"📄 Pages: {len(pdf.pages)}")
-                    st.info(f"🔒 Contains signature markers: {'Yes' if has_signature_text else 'No'}")
-                    
-                    # Display hash for document tracking
-                    st.code(f"Document Hash: {doc_hash[:16]}...{doc_hash[-16:]}")
-                    
-                    # Document size and characteristics
-                    file_size = len(content) / 1024  # KB
-                    st.info(f"📦 File size: {file_size:.2f} KB")
-                
-                with col2:
-                    st.subheader("Verification Results")
+                if verify_file:
+                    content = verify_file.read()
                     
-                    # Case 1: Document has signature markers
-                    if has_signature_text:
-                        if metadata_valid and content_consistent:
-                            st.success("✅ Document Status: VERIFIED AUTHENTIC")
-                            st.markdown("- ✓ Valid PDF structure")
-                            st.markdown("- ✓ Signature information detected")
-                            st.markdown("- ✓ No tampering indicators found")
-                            st.markdown("- ✓ Metadata consistency verified")
-                        else:
-                            st.warning("⚠️ Document Status: POTENTIALLY MODIFIED")
-                            st.markdown("- ✓ Valid PDF structure")
-                            st.markdown("- ✓ Signature information found")
-                            st.markdown("- ❌ Some integrity checks failed")
+                    try:
+                        # Basic PDF validation
+                        pdf = PdfReader(BytesIO(content))
+                        
+                        # Extract text to look for signature markers
+                        all_text = ""
+                        for page in pdf.pages:
+                            all_text += page.extract_text() or ""
+                        
+                        # Check for digital signature information
+                        has_signature_text = any(sig_text in all_text.lower() for sig_text in 
+                                                ["signed by:", "digital signature", "electronic signature"])
+                        
+                        # Create document fingerprint/hash
+                        doc_hash = hashlib.sha256(content).hexdigest()
+                        
+                        # Calculate metadata integrity
+                        metadata_valid = True
+                        if pdf.metadata:
+                            try:
+                                # Check for suspicious metadata modifications
+                                creation_date = pdf.metadata.get('/CreationDate', '')
+                                mod_date = pdf.metadata.get('/ModDate', '')
+                                if mod_date and creation_date:
+                                    metadata_valid = mod_date >= creation_date
+                            except:
+                                metadata_valid = False
+                        
+                        # Check for content consistency
+                        content_consistent = True
+                        
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            st.subheader("Document Analysis")
+                            st.info(f"📄 Pages: {len(pdf.pages)}")
+                            st.info(f"🔒 Contains signature markers: {'Yes' if has_signature_text else 'No'}")
+                            
+                            # Display hash for document tracking
+                            st.code(f"Document Hash: {doc_hash[:16]}...{doc_hash[-16:]}")
                             
-                            if not metadata_valid:
-                                st.markdown("- ❌ Metadata inconsistencies detected")
+                            # Document size and characteristics
+                            file_size = len(content) / 1024  # KB
+                            st.info(f"📦 File size: {file_size:.2f} KB")
                         
-                        # Display signature extraction if present
-                        signature_line = next((line for line in all_text.split('\n') if "signed by:" in line.lower()), "")
-                        if signature_line:
-                            st.info(f"📝 {signature_line.strip()}")
-                    
-                    # Case 2: Document without signatures
-                    else:
-                        if metadata_valid and content_consistent:
-                            st.success("✅ Document Status: VALID DOCUMENT")
-                            st.markdown("- ✓ Valid PDF structure")
-                            st.markdown("- ✓ Content integrity verified")
-                            st.markdown("- ✓ No tampering indicators found")
-                            st.markdown("- ℹ️ No signature information found (this is not an error)")
-                        else:
-                            st.warning("⚠️ Document Status: POTENTIALLY MODIFIED")
-                            st.markdown("- ✓ Valid PDF structure")
-                            st.markdown("- ❌ Some integrity checks failed")
+                        with col2:
+                            st.subheader("Verification Results")
                             
-                            if not metadata_valid:
-                                st.markdown("- ❌ Metadata inconsistencies detected")
-                
-                # Advanced options
-                with st.expander("🔬 Advanced Verification Details"):
-                    st.markdown("### Document Metadata")
-                    if pdf.metadata:
-                        for key, value in pdf.metadata.items():
-                            if key and value and key not in ('/CreationDate', '/ModDate'):
-                                st.text(f"{key}: {value}")
-                    else:
-                        st.text("No metadata available")
-                    
-                    st.markdown("### Integrity Timeline")
-                    st.text(f"Creation Date: {pdf.metadata.get('/CreationDate', 'Not available')}")
-                    st.text(f"Last Modified: {pdf.metadata.get('/ModDate', 'Not available')}")
-                    
-                    # Additional verification for content integrity
-                    st.markdown("### Content Analysis")
-                    fonts_used = set()
-                    image_count = 0
-                    for page in pdf.pages:
-                        if "/Font" in page["/Resources"]:
-                            for font in page["/Resources"]["/Font"]:
-                                fonts_used.add(str(font))
-                        if "/XObject" in page["/Resources"]:
-                            for obj in page["/Resources"]["/XObject"]:
-                                if "/Subtype" in page["/Resources"]["/XObject"][obj] and \
-                                   page["/Resources"]["/XObject"][obj]["/Subtype"] == "/Image":
-                                    image_count += 1
-                    
-                    st.text(f"Fonts detected: {len(fonts_used)}")
-                    st.text(f"Images detected: {image_count}")
-                    
-            except Exception as e:
-                st.error(f"❌ Document Status: INVALID OR CORRUPTED")
-                st.markdown(f"Error: Could not process the document properly. The file may be corrupted or not a valid PDF.")
-                st.markdown(f"Technical details: {str(e)}")
+                            # Case 1: Document has signature markers
+                            if has_signature_text:
+                                if metadata_valid and content_consistent:
+                                    st.success("✅ Document Status: VERIFIED AUTHENTIC")
+                                    st.markdown("- ✓ Valid PDF structure")
+                                    st.markdown("- ✓ Signature information detected")
+                                    st.markdown("- ✓ No tampering indicators found")
+                                    st.markdown("- ✓ Metadata consistency verified")
+                                else:
+                                    st.warning("⚠️ Document Status: POTENTIALLY MODIFIED")
+                                    st.markdown("- ✓ Valid PDF structure")
+                                    st.markdown("- ✓ Signature information found")
+                                    st.markdown("- ❌ Some integrity checks failed")
+                                    
+                                    if not metadata_valid:
+                                        st.markdown("- ❌ Metadata inconsistencies detected")
+                                
+                                # Display signature extraction if present
+                                signature_line = next((line for line in all_text.split('\n') if "signed by:" in line.lower()), "")
+                                if signature_line:
+                                    st.info(f"📝 {signature_line.strip()}")
+                            
+                            # Case 2: Document without signatures
+                            else:
+                                if metadata_valid and content_consistent:
+                                    st.success("✅ Document Status: VALID DOCUMENT")
+                                    st.markdown("- ✓ Valid PDF structure")
+                                    st.markdown("- ✓ Content integrity verified")
+                                    st.markdown("- ✓ No tampering indicators found")
+                                    st.markdown("- ℹ️ No signature information found (this is not an error)")
+                                else:
+                                    st.warning("⚠️ Document Status: POTENTIALLY MODIFIED")
+                                    st.markdown("- ✓ Valid PDF structure")
+                                    st.markdown("- ❌ Some integrity checks failed")
+                                    
+                                    if not metadata_valid:
+                                        st.markdown("- ❌ Metadata inconsistencies detected")
+                        
+                        # Advanced options
+                        with st.expander("🔬 Advanced Verification Details"):
+                            st.markdown("### Document Metadata")
+                            if pdf.metadata:
+                                for key, value in pdf.metadata.items():
+                                    if key and value and key not in ('/CreationDate', '/ModDate'):
+                                        st.text(f"{key}: {value}")
+                            else:
+                                st.text("No metadata available")
+                            
+                            st.markdown("### Integrity Timeline")
+                            st.text(f"Creation Date: {pdf.metadata.get('/CreationDate', 'Not available')}")
+                            st.text(f"Last Modified: {pdf.metadata.get('/ModDate', 'Not available')}")
+                            
+                            # Additional verification for content integrity
+                            st.markdown("### Content Analysis")
+                            fonts_used = set()
+                            image_count = 0
+                            for page in pdf.pages:
+                                if "/Font" in page["/Resources"]:
+                                    for font in page["/Resources"]["/Font"]:
+                                        fonts_used.add(str(font))
+                                if "/XObject" in page["/Resources"]:
+                                    for obj in page["/Resources"]["/XObject"]:
+                                        if "/Subtype" in page["/Resources"]["/XObject"][obj] and \
+                                        page["/Resources"]["/XObject"][obj]["/Subtype"] == "/Image":
+                                            image_count += 1
+                            
+                            st.text(f"Fonts detected: {len(fonts_used)}")
+                            st.text(f"Images detected: {image_count}")
+                            
+                    except Exception as e:
+                        st.error(f"❌ Document Status: INVALID OR CORRUPTED")
+                        st.markdown(f"Error: Could not process the document properly. The file may be corrupted or not a valid PDF.")
+                        st.markdown(f"Technical details: {str(e)}")