# Simple image classifier using transfer learning
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model

# Assume image data is organized in 'data/train/{class1}', 'data/train/{class2}', etc.
IMAGE_SIZE = (224, 224)
BATCH_SIZE = 32
NUM_CLASSES = 2 # Example: Healthy vs Diseased
# Placeholder directory - replace with your actual path or create dummy data
TRAIN_DIR = 'data/train' 

# Create dummy data directories if they don't exist (for demonstration)
import os
if not os.path.exists(os.path.join(TRAIN_DIR, 'class1')): os.makedirs(os.path.join(TRAIN_DIR, 'class1'))
if not os.path.exists(os.path.join(TRAIN_DIR, 'class2')): os.makedirs(os.path.join(TRAIN_DIR, 'class2'))
# Add placeholder files if dirs are empty to avoid flow_from_directory error
if not os.listdir(os.path.join(TRAIN_DIR, 'class1')): open(os.path.join(TRAIN_DIR, 'class1', 'dummy1.jpg'), 'a').close()
if not os.listdir(os.path.join(TRAIN_DIR, 'class2')): open(os.path.join(TRAIN_DIR, 'class2', 'dummy2.jpg'), 'a').close()


# Set up image data generators with augmentation
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2, # Added shear
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest' # Added fill_mode
)

# Load training data from directory
try:
    train_generator = train_datagen.flow_from_directory(
        TRAIN_DIR,
        target_size=IMAGE_SIZE,
        batch_size=BATCH_SIZE,
        class_mode='categorical' # Use 'binary' if NUM_CLASSES = 1 (sigmoid activation)
    )
    NUM_CLASSES = train_generator.num_classes # Get actual number of classes
except Exception as e:
    print(f"Error loading data from {TRAIN_DIR}: {e}")
    print("Ensure the directory exists and contains subdirectories for each class with images.")
    # Assign dummy values to prevent further errors in demo
    train_generator = None 
    NUM_CLASSES = 2 

if train_generator: # Proceed only if data loaded
    # Create a base model using transfer learning (MobileNetV2 is lightweight)
    base_model = MobileNetV2(input_shape=IMAGE_SIZE + (3,), # Specify input shape
                            weights='imagenet',
                            include_top=False) # Exclude the final classification layer

    # Freeze the base model layers initially
    base_model.trainable = False

    # Add custom classification layers
    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    # x = Dense(1024, activation='relu')(x) # Optional intermediate dense layer
    predictions = Dense(NUM_CLASSES, activation='softmax')(x) # Use 'sigmoid' for binary

    # Create the final model
    model = Model(inputs=base_model.input, outputs=predictions)

    # Compile the model
    model.compile(optimizer='adam',
                loss='categorical_crossentropy', # Use 'binary_crossentropy' for binary
                metrics=['accuracy'])
    
    print("Model Summary:")
    model.summary() # Print model structure

    # Train the model (replace steps_per_epoch if needed)
    print(f"\nStarting training with {train_generator.samples} images...")
    # steps_per_epoch = train_generator.samples // BATCH_SIZE # Calculate steps
    # model.fit(train_generator, epochs=1, steps_per_epoch=steps_per_epoch) # Train for 1 epoch in demo
    
    # Dummy fit call if generator failed, just to show structure
    # import numpy as np
    # model.fit(np.random.rand(BATCH_SIZE, *IMAGE_SIZE, 3), np.random.rand(BATCH_SIZE, NUM_CLASSES), epochs=1) 


    # Optional: Fine-tuning steps (usually done after initial training)
    # base_model.trainable = True 
    # fine_tune_at = 100 # Example layer index
    # for layer in base_model.layers[:fine_tune_at]: layer.trainable = False
    # model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5), loss='categorical_crossentropy', metrics=['accuracy'])
    # model.fit(train_generator, epochs=1, initial_epoch=0) # Continue training


    # Save the model
    try:
        model.save('plant_classifier_model.keras') # Use .keras format
        print("Model saved as plant_classifier_model.keras")
    except Exception as e:
        print(f"Error saving model: {e}")
else:
    print("\nSkipping model creation and training due to data loading error.")

# Simple sentiment analysis using Hugging Face Transformers pipeline
# Ensure transformers and a backend (torch or tensorflow) are installed
# pip install transformers torch # or tensorflow

from transformers import pipeline
import sys # For checking module availability

try:
    # Load a pre-trained sentiment analysis pipeline
    # Uses a DistilBERT model fine-tuned on SST-2 dataset by default
    print("Loading sentiment analysis pipeline...")
    sentiment_pipeline = pipeline("sentiment-analysis")
    print("Pipeline loaded.")

    # Example usage
    reviews = [
        "This product is amazing! I love it.",
        "I am quite disappointed with the quality.",
        "It's okay, not great but not terrible either."
    ]

    results = sentiment_pipeline(reviews)

    # Print results
    print("\n--- Sentiment Analysis ---")
    for review, result in zip(reviews, results):
        print(f"Review: {review}")
        print(f"Label: {result['label']}, Score: {result['score']:.4f}\n")

except Exception as e:
     print(f"\nError loading/using sentiment pipeline: {e}", file=sys.stderr)
     print("Please ensure 'transformers' and 'torch' (or 'tensorflow') are installed.", file=sys.stderr)


try:
    # --- OR ---
    # Example: Zero-shot classification (classify text without specific training)
    print("\nLoading zero-shot classification pipeline...")
    # Using a smaller model for faster loading in demo if needed
    # model_name = "valhalla/distilbart-mnli-12-3" 
    model_name = "facebook/bart-large-mnli"
    zero_shot_classifier = pipeline("zero-shot-classification", model=model_name)
    print("Pipeline loaded.")

    sequence_to_classify = "Apple released the new Vision Pro headset today."
    candidate_labels = ['technology', 'politics', 'business', 'sports', 'health']
    result = zero_shot_classifier(sequence_to_classify, candidate_labels)

    print("\n--- Zero-Shot Classification ---")
    print(f"Text: {sequence_to_classify}")
    print(f"Predicted Labels: {result['labels']}")
    print(f"Scores: {[f'{s:.4f}' for s in result['scores']]}")

except Exception as e:
     print(f"\nError loading/using zero-shot pipeline: {e}", file=sys.stderr)
     print("Please ensure 'transformers' and 'torch' (or 'tensorflow') are installed.", file=sys.stderr)


print("\nNote: For custom training, more code involving datasets,")
print("tokenizers, and the Trainer API is needed.")
                                

# Simple collaborative filtering recommendation system using Surprise
# Ensure Surprise and Pandas are installed: pip install scikit-surprise pandas

import pandas as pd
from surprise import Dataset, Reader, SVD
from surprise.model_selection import cross_validate
from collections import defaultdict
import sys # For error messages

# --- Data Loading ---
# Attempt to load real data, fall back to dummy data for demonstration
try:
    # Replace 'user_ratings.csv' with the actual path to your data file
    # Expected CSV format: user_id, item_id, rating
    data = pd.read_csv('user_ratings.csv') 
    print(f"Loaded data from user_ratings.csv ({len(data)} ratings)")
except FileNotFoundError:
    print("Warning: 'user_ratings.csv' not found.", file=sys.stderr)
    print("Using dummy data for demonstration.", file=sys.stderr)
    dummy_data = {'user_id': [1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5],
                  'item_id': [101, 102, 103, 101, 104, 102, 104, 105, 101, 103, 105, 102, 104, 105],
                  'rating':  [5, 3, 4, 4, 2, 5, 3, 4, 4, 5, 2, 3, 5, 4]}
    data = pd.DataFrame(dummy_data)
except Exception as e:
    print(f"Error loading rating data: {e}", file=sys.stderr)
    sys.exit(1) # Exit if data loading fails critically

# --- Surprise Dataset Preparation ---
try:
    # Define the rating scale based on your data
    min_rating = data['rating'].min()
    max_rating = data['rating'].max()
    reader = Reader(rating_scale=(min_rating, max_rating))

    # Load data into Surprise dataset format
    dataset = Dataset.load_from_df(data[['user_id', 'item_id', 'rating']], reader)

    # Build the full training set (using all data for final recommendations)
    trainset = dataset.build_full_trainset()
    print("Surprise trainset built.")
except Exception as e:
    print(f"Error preparing Surprise dataset: {e}", file=sys.stderr)
    sys.exit(1)


# --- Model Training ---
# Choose a model (SVD is a good baseline)
# Hyperparameters can be tuned using GridSearchCV
model = SVD(n_factors=50, n_epochs=25, lr_all=0.005, reg_all=0.02, random_state=42)

print("\nTraining collaborative filtering model (SVD)...")
try:
    model.fit(trainset)
    print("Model training complete.")
except Exception as e:
    print(f"Error training model: {e}", file=sys.stderr)
    sys.exit(1)

# --- (Optional) Model Evaluation ---
# Use cross-validation to get an estimate of performance
# print("\nRunning 3-fold cross-validation...")
# try:
#     cv_results = cross_validate(model, dataset, measures=['RMSE', 'MAE'], cv=3, verbose=True)
#     # print("Cross-validation results (average):", pd.DataFrame(cv_results).mean())
# except Exception as e:
#     print(f"Error during cross-validation: {e}", file=sys.stderr)


# --- Recommendation Generation ---
def get_top_n_recommendations_for_user(user_id, n=10):
    """Generates top N recommendations for a given user."""
    try:
        # Convert raw user ID to Surprise internal ID
        user_inner_id = trainset.to_inner_uid(user_id)
    except ValueError:
        # Handle case where user is not in the training set (cold start)
        print(f"Warning: User {user_id} not found in training data (cold start user). Cannot generate collaborative filtering recommendations.", file=sys.stderr)
        return [] # Or fallback to popular items

    # Get items the user has already interacted with
    user_rated_items_inner = {item_inner for (item_inner, rating) in trainset.ur[user_inner_id]}

    # Predict ratings for all items the user hasn't interacted with
    predictions = []
    all_items_inner = trainset.all_items()
    for item_inner_id in all_items_inner:
        if item_inner_id not in user_rated_items_inner:
            item_raw_id = trainset.to_raw_iid(item_inner_id)
            # Predict rating using the trained model
            predicted_rating = model.predict(user_id, item_raw_id).est
            predictions.append((item_raw_id, predicted_rating))

    # Sort predictions by estimated rating (highest first)
    predictions.sort(key=lambda x: x[1], reverse=True)

    # Return top N recommended item IDs
    top_n_items = [item_id for item_id, rating in predictions[:n]]
    return top_n_items

# --- Example Usage ---
target_user_id = 3 # Change this to test different users
num_recommendations = 5

print(f"\nGenerating top {num_recommendations} recommendations for user {target_user_id}...")
recommendations = get_top_n_recommendations_for_user(target_user_id, n=num_recommendations)

if recommendations:
    print(f"-> Recommendations: {recommendations}")
else:
    # Handle cases where no recommendations could be generated (e.g., cold start)
    print(f"-> Could not generate recommendations for user {target_user_id}.")

print("\nNote: This is a basic example. Production systems often involve:")
print("- Handling cold-start users/items (e.g., popularity fallback)")
print("- Incorporating item content features (content-based/hybrid models)")
print("- Feature engineering and context awareness")
print("- More sophisticated evaluation and hyperparameter tuning")
print("- Building an API to serve recommendations efficiently")

# Sample Rasa Implementation Outline (Requires Rasa installation)
# Illustrates key file structures and concepts

# --- Installation ---
# pip install rasa

# --- Project Initialization ---
# In your terminal, navigate to your desired directory and run:
# rasa init
# (This creates the standard Rasa project structure with example files)

# --- Key File Modifications (Illustrative) ---

# 1. Define NLU training data (data/nlu.yml)
#    Intents represent user goals, examples are how users might phrase them.
# --- data/nlu.yml ---
version: "3.1"
nlu:
- intent: greet
  examples: |
    - hey there
    - hello
    - hi bot
    - good morning
    - yo

- intent: ask_product_info
  examples: |
    - what can you tell me about your products?
    - what services do you offer?
    - show me what you sell
    - product details please

- intent: check_availability
  examples: |
    - is [productA](product_name) in stock?  # Example entity annotation
    - do you have [productB](product_name)?
    - availability of [widget](product_name)

- intent: goodbye
  examples: |
    - bye bye
    - see ya
    - ok thanks goodbye

# 2. Define Dialogue Stories (data/stories.yml)
#    Stories define example conversation paths.
# --- data/stories.yml ---
version: "3.1"
stories:
- story: happy path with product info
  steps:
  - intent: greet
  - action: utter_greet            # Bot response defined in domain.yml
  - intent: ask_product_info
  - action: utter_product_info     # Bot response defined in domain.yml
  - intent: goodbye
  - action: utter_goodbye          # Bot response defined in domain.yml

- story: check product availability path
  steps:
  - intent: greet
  - action: utter_greet
  - intent: check_availability     # User asks about a product
    entities:
    - product_name: "productA"     # Rasa extracts the entity
  - action: action_check_stock    # Custom action to check backend
  - intent: goodbye
  - action: utter_goodbye

# 3. Define Domain (domain.yml - All bot knowledge)
# --- domain.yml ---
version: "3.1"
intents:  # List all intents used in nlu.yml
  - greet
  - ask_product_info
  - check_availability # Added intent
  - goodbye

entities: # List all entities used
  - product_name

# Define standard template responses
responses:
  utter_greet:
  - text: "Hello! How can I assist you today?"

  utter_product_info:
  - text: "We specialize in AI solutions like custom chatbots, recommendation engines, and image analysis tools."

  utter_goodbye:
  - text: "Take care! Feel free to reach out anytime."

  utter_product_in_stock:
  - text: "Good news! {product_name} is currently in stock." # Uses extracted entity

  utter_product_out_of_stock:
  - text: "Unfortunately, {product_name} is out of stock right now."

# List all actions the bot can perform (responses & custom code)
actions:
  - utter_greet
  - utter_product_info
  - utter_goodbye
  - utter_product_in_stock     # Added response action
  - utter_product_out_of_stock # Added response action
  - action_check_stock         # Custom action defined in actions.py

session_config:
  session_expiration_time: 60 # minutes
  carry_over_slots_to_new_session: true

# 4. Define Custom Actions (actions/actions.py)
#    Code to interact with external systems (databases, APIs).
# --- actions/actions.py ---
from typing import Any, Text, Dict, List
from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
import random # For dummy logic

class ActionCheckStock(Action):
    def name(self) -> Text:
        return "action_check_stock" # Must match name in domain.yml

    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:

        # Get the product name extracted by Rasa NLU
        product = next(tracker.get_latest_entity_values("product_name"), None)

        if not product:
            dispatcher.utter_message(text="Sorry, which product are you asking about?")
            return []

        # --- Dummy stock checking logic ---
        # Replace this with actual database/API call
        print(f"Checking stock for: {product}") # Log for debugging
        is_in_stock = random.choice([True, False]) # Dummy check
        # ----------------------------------

        if is_in_stock:
            # Use utter_message with the specific response template from domain.yml
            dispatcher.utter_message(response="utter_product_in_stock", product_name=product)
        else:
            dispatcher.utter_message(response="utter_product_out_of_stock", product_name=product)

        return [] # Return empty list unless setting slots

# --- Training & Running ---

# 5. Train the NLU and Core models:
#    rasa train

# 6. Run the action server (if you have custom actions):
#    rasa run actions &

# 7. Run the Rasa server to talk via API or shell:
#    rasa shell
#    OR
#    rasa run --enable-api --cors "*" # To expose HTTP API