import os
import subprocess
import sys

# Attempt to install pytesseract if not found
try:
    import pytesseract
except ImportError:
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'pytesseract'])
    import pytesseract

# Set Tesseract path
pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'

def extract_text_from_image(image):
    try:
        if image is None:
            return "No image captured. Please try again."
        
        # Verify Tesseract executable
        if not os.path.exists('/usr/bin/tesseract'):
            return "Tesseract OCR is not installed. Please install tesseract-ocr."
        
        text = pytesseract.image_to_string(image)
        
        if not text.strip():
            return "No text could be extracted. Ensure image is clear and readable."
        
        return text
    except Exception as e:
        return f"Error extracting text: {str(e)}"
import gradio as gr
import re
import numpy as np
from PIL import Image
import pytesseract
import requests
import json
import os
from dotenv import load_dotenv
import google.generativeai as genai

# Load environment variables
load_dotenv()

# Configure Gemini API
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
genai.configure(api_key=GEMINI_API_KEY)


# Function to extract text from images using OCR
def extract_text_from_image(image):
    try:
        if image is None:
            return "No image captured. Please try again."
        text = pytesseract.image_to_string(image)
        return text
    except Exception as e:
        return f"Error extracting text: {str(e)}"

# Function to parse ingredients from text
def parse_ingredients(text):
    # Basic parsing - split by commas, semicolons, and line breaks
    if not text:
        return []

    # Clean up the text - remove "Ingredients:" prefix if present
    text = re.sub(r'^ingredients:?\s*', '', text.lower(), flags=re.IGNORECASE)

    # Split by common ingredient separators
    ingredients = re.split(r',|;|\n', text)
    ingredients = [i.strip().lower() for i in ingredients if i.strip()]
    return ingredients

# Function to analyze ingredients with Gemini
def analyze_ingredients_with_gemini(ingredients_list, health_conditions=None):
    """
    Use Gemini to analyze ingredients and provide health insights
    """
    if not ingredients_list:
        return "No ingredients detected or provided."

    # Prepare the list of ingredients for the prompt
    ingredients_text = ", ".join(ingredients_list)

    # Create a prompt for Gemini
    if health_conditions and health_conditions.strip():
        prompt = f"""
        Analyze the following food ingredients for a person with these health conditions: {health_conditions}

        Ingredients: {ingredients_text}

        For each ingredient:
        1. Provide its potential health benefits
        2. Identify any potential risks
        3. Note if it may affect the specified health conditions

        Then provide an overall assessment of the product's suitability for someone with the specified health conditions.
        Format your response in markdown with clear headings and sections.
        """
    else:
        prompt = f"""
        Analyze the following food ingredients:

        Ingredients: {ingredients_text}

        For each ingredient:
        1. Provide its potential health benefits
        2. Identify any potential risks or common allergens associated with it

        Then provide an overall assessment of the product's general health profile.
        Format your response in markdown with clear headings and sections.
        """

    try:
        # Call the Gemini API
        model = genai.GenerativeModel('gemini-pro')
        response = model.generate_content(prompt)

        # Extract and return the analysis
        analysis = response.text

        # Add disclaimer
        disclaimer = """
        ## Disclaimer
        This analysis is provided for informational purposes only and should not replace professional medical advice.
        Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
        """

        return analysis + disclaimer

    except Exception as e:
        # Fallback to basic analysis if API call fails
        return f"Error connecting to analysis service: {str(e)}\n\nPlease try again later."

# Function to process input based on method (camera, upload, or manual entry)
def process_input(input_method, text_input, camera_input, upload_input, health_conditions):
    if input_method == "Camera":
        if camera_input is not None:
            extracted_text = extract_text_from_image(camera_input)
            ingredients = parse_ingredients(extracted_text)
            return analyze_ingredients_with_gemini(ingredients, health_conditions)
        else:
            return "No camera image captured. Please try again."

    elif input_method == "Image Upload":
        if upload_input is not None:
            extracted_text = extract_text_from_image(upload_input)
            ingredients = parse_ingredients(extracted_text)
            return analyze_ingredients_with_gemini(ingredients, health_conditions)
        else:
            return "No image uploaded. Please try again."

    elif input_method == "Manual Entry":
        if text_input.strip():
            ingredients = parse_ingredients(text_input)
            return analyze_ingredients_with_gemini(ingredients, health_conditions)
        else:
            return "No ingredients entered. Please try again."

    return "Please provide input using one of the available methods."

# Create the Gradio interface
with gr.Blocks(title="AI Ingredient Scanner") as app:
    gr.Markdown("# AI Ingredient Scanner")
    gr.Markdown("Scan product ingredients and analyze them for health benefits, risks, and potential allergens.")

    with gr.Row():
        with gr.Column():
            input_method = gr.Radio(
                ["Camera", "Image Upload", "Manual Entry"],
                label="Input Method",
                value="Camera"
            )

            # Camera input
            camera_input = gr.Image(label="Capture ingredients with camera", type="pil")

            # Image upload
            upload_input = gr.Image(label="Upload image of ingredients label", type="pil", visible=False)

            # Text input
            text_input = gr.Textbox(
                label="Enter ingredients list (comma separated)",
                placeholder="milk, sugar, flour, eggs, vanilla extract",
                lines=3,
                visible=False
            )

            # Health conditions input - now optional and more flexible
            health_conditions = gr.Textbox(
                label="Enter your health concerns (optional)",
                placeholder="diabetes, high blood pressure, peanut allergy, etc.",
                lines=2,
                info="The AI will automatically analyze ingredients for these conditions"
            )

            analyze_button = gr.Button("Analyze Ingredients")

        with gr.Column():
            output = gr.Markdown(label="Analysis Results")
            extracted_text_output = gr.Textbox(label="Extracted Text (for verification)", lines=3)

    # Show/hide inputs based on selection
    def update_visible_inputs(choice):
        return {
            upload_input: choice == "Image Upload",
            camera_input: choice == "Camera",
            text_input: choice == "Manual Entry"
        }

    input_method.change(update_visible_inputs, input_method, [upload_input, camera_input, text_input])

    # Extract and display the raw text (for verification purposes)
    def show_extracted_text(input_method, text_input, camera_input, upload_input):
        if input_method == "Camera" and camera_input is not None:
            return extract_text_from_image(camera_input)
        elif input_method == "Image Upload" and upload_input is not None:
            return extract_text_from_image(upload_input)
        elif input_method == "Manual Entry":
            return text_input
        return "No input detected"

    # Set up event handlers
    analyze_button.click(
        fn=process_input,
        inputs=[input_method, text_input, camera_input, upload_input, health_conditions],
        outputs=output
    )

    analyze_button.click(
        fn=show_extracted_text,
        inputs=[input_method, text_input, camera_input, upload_input],
        outputs=extracted_text_output
    )

    gr.Markdown("### How to use")
    gr.Markdown("""
    1. Choose your input method (Camera, Image Upload, or Manual Entry)
    2. Take a photo of the ingredients label or enter ingredients manually
    3. Optionally enter your health concerns
    4. Click "Analyze Ingredients" to get your personalized analysis

    The AI will automatically analyze the ingredients, their health implications, and their potential impact on your specific health concerns.
    """)

    gr.Markdown("### Examples of what you can ask")
    gr.Markdown("""
    The system can handle a wide range of health concerns, such as:
    - General health goals: "trying to reduce sugar intake" or "watching sodium levels"
    - Medical conditions: "diabetes" or "hypertension"
    - Allergies: "peanut allergy" or "shellfish allergy"
    - Dietary restrictions: "vegetarian" or "gluten-free diet"
    - Multiple conditions: "diabetes, high cholesterol, and lactose intolerance"

    The AI will tailor its analysis to your specific needs.
    """)

    gr.Markdown("### Tips for best results")
    gr.Markdown("""
    - Hold the camera steady and ensure good lighting
    - Focus directly on the ingredients list
    - Make sure the text is clear and readable
    - Be specific about your health concerns for more targeted analysis
    """)

    gr.Markdown("### Disclaimer")
    gr.Markdown("""
    This tool is for informational purposes only and should not replace professional medical advice.
    Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
    """)

# Function to run when testing without API key
def run_with_dummy_llm():
    # Override the LLM function with a dummy version for testing
    global analyze_ingredients_with_gemini

    def dummy_analyze(ingredients_list, health_conditions=None):
        ingredients_text = ", ".join(ingredients_list)

        report = f"""
        # Ingredient Analysis Report

        ## Detected Ingredients
        {", ".join([i.title() for i in ingredients_list])}

        ## Overview
        This is a simulated analysis since no API key was provided. In the actual application,
        the ingredients would be analyzed by an LLM for their health implications.

        ## Health Considerations
        """

        if health_conditions:
            report += f"""
            The analysis would specifically consider these health concerns: {health_conditions}
            """
        else:
            report += """
            No specific health concerns were provided, so a general analysis would be performed.
            """

        report += """
        ## Disclaimer
        This analysis is provided for informational purposes only and should not replace professional medical advice.
        Always consult with a healthcare provider regarding dietary restrictions, allergies, or health conditions.
        """

        return report

    # Replace the real function with the dummy
    analyze_ingredients_with_gemini = dummy_analyze

    # Launch the app
    app.launch()

# Launch the app
if __name__ == "__main__":
    # Check if API key exists
    if not os.getenv("GEMINI_API_KEY"):
        print("WARNING: No Gemini API key found. Running with simulated LLM responses.")
        run_with_dummy_llm()
    else:
        app.launch()