app.py

"""
⚡ Performance Optimization & Dataset Integration ⚡

1. Website Loading:
   - Telegram and Gmail email sending are commented out to avoid
     restrictions on Hugging Face free trial spaces.
   - Focus on fast page load and smooth API responses.
   - Images are served from optimized folders for faster rendering.

2. Booking Data:
   - All booking data is now saved directly to Hugging Face Dataset
     using save_output_to_dataset().
   - Local JSON file writes are disabled to reduce disk I/O and latency.
   - Each booking is stored with a timestamp and full user/product info.

3. API Updates:
   - search_image and search_text APIs are fully functional.
   - Frontend can use these APIs without delay.
   - Optimized static files are served via /optimized/ route.

Overall, these changes improve website performance, reduce dependency on
external services, and securely store all booking data in the cloud dataset.
"""

from huggingface_hub import HfApi
from datetime import datetime
from flask import Flask, request, jsonify, render_template, send_from_directory
from siglip_search_2 import search_image, search_text # ✅ functions for search
import os
import json
import requests
import base64
import io
import mimetypes
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

env_blob = os.environ.get("find_it_or_create", "")
secrets = {}

for line in env_blob.splitlines():
    if "=" in line:
        k, v = line.split("=", 1)
        secrets[k.strip()] = v.strip().strip('"')

# Helper function → checks normal env first, then blob
def get_secret(key: str, default=None):
    return os.environ.get(key) or secrets.get(key, default)


# -----------------------------
# Gmail SMTP settings
# -----------------------------
GMAIL_USER = get_secret("GMAIL_USER")
GMAIL_PASSWORD = get_secret("GMAIL_PASSWORD")

# -----------------------------
# Telegram bot integration
# -----------------------------
bot_token = get_secret("TELEGRAM_BOT_TOKEN")
chat_id = get_secret("TELEGRAM_CHAT_ID")




BOOKING_FILE = "bookings.json"
UPLOAD_FOLDER = "uploads"

# os.makedirs(UPLOAD_FOLDER, exist_ok=True)

# -----------------------------
# Telegram bot integration
# -----------------------------

# bot_token = os.environ.get("TELEGRAM_BOT_TOKEN")
# chat_id = os.environ.get("TELEGRAM_CHAT_ID")

env_blob = os.environ.get("find_it_or_create", "")
secrets = {}

for line in env_blob.splitlines():
    if "=" in line:
        k, v = line.split("=", 1)
        secrets[k.strip()] = v.strip().strip('"')



hf_token = get_secret("HF_TOKEN")
dataset_repo = "mlbhanuprakash/data"  # 👈 your private dataset

api = HfApi()

def save_output_to_dataset(output):
    # Create a timestamp-based filename (replace ':' with '-')
    timestamp = datetime.now().isoformat().replace(":", "-")
    filename = f"data_{timestamp}.json"
    local_file = f"/tmp/{filename}"

    # Prepare data to save
    entry = {
        "timestamp": datetime.now().isoformat(),
        "output": output
    }

    # Write the data to a local JSON file
    with open(local_file, "w") as f:
        json.dump(entry, f, indent=2)

    # Upload that file as a new entry in your dataset
    api.upload_file(
        path_or_fileobj=local_file,
        path_in_repo="JSON_data/"+filename,          # 👈 unique file each time
        repo_id=dataset_repo,
        token=hf_token,
        repo_type="dataset",
        commit_message=f"Add new output file {filename}"
    )

    print(f"✅ Output saved as {filename} in Hugging Face Dataset!")


UPLOAD_FOLDER = "/tmp"  # safe writable folder in Spaces




""""
def send_email(to_email, subject, body, product_image_str=None):
    msg = MIMEMultipart()
    msg['From'] = GMAIL_USER
    msg['To'] = to_email
    msg['Subject'] = subject

    # Attach text body
    msg.attach(MIMEText(body, 'plain'))

    # If product image is available, try attaching
    if product_image_str:
        try:
            img_bytes = None

            # Case 1: Data URI (base64)
            if product_image_str.startswith("data:"):
                header, b64data = product_image_str.split(",", 1)
                img_bytes = base64.b64decode(b64data)

            # Case 2: HTTP(S) URL → download the image
            elif product_image_str.startswith("http://") or product_image_str.startswith("https://"):
                resp = requests.get(product_image_str, timeout=10)
                if resp.status_code == 200:
                    img_bytes = resp.content

            # Case 3: Local file path
            elif os.path.exists(product_image_str):
                with open(product_image_str, "rb") as f:
                    img_bytes = f.read()

            # If we got image bytes, attach them
            if img_bytes:
                image = MIMEImage(img_bytes, name="product_image.jpg")
                msg.attach(image)

        except Exception as e:
            app.logger.error(f"Failed to attach product image: {e}")

    # Send email via Gmail SMTP
    try:
        with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
            server.login(GMAIL_USER, GMAIL_PASSWORD)
            server.sendmail(GMAIL_USER, to_email, msg.as_string())
            app.logger.info(f"Email sent to {to_email}")
    except Exception as e:
        app.logger.error(f"Email sending failed: {e}")
        return False
    return True"""

# -----------------------------
# Homepage
# -----------------------------
@app.route("/")
def index():
    return render_template("index.html")

# -----------------------------
# Image Search API
# -----------------------------
@app.route("/search_image", methods=["POST"])

def search_image_api():
    """Handle image upload and run SigLIP image search"""
    if "file" not in request.files:
        return jsonify({"error": "No file uploaded"}), 400

    file = request.files["file"]
    if file.filename == "":
        return jsonify({"error": "Empty filename"}), 400

    filepath = os.path.join(UPLOAD_FOLDER, file.filename)
    file.save(filepath)
    app.logger.info(f"Received image: {filepath}")
    try:
        results = search_image(filepath, topk=1)  # ✅ already working
        app.logger.info(f"Returning {len(results)} image results")
    except Exception as e:
        app.logger.error(f"{e}")
        return jsonify({"error": str(e)}), 500

    return jsonify(results)

        

# -----------------------------
# Text Search API
# -----------------------------
@app.route("/search_text", methods=["POST"])
def search_text_api():
    """Handle text query and run SigLIP text search"""
    data = request.get_json()
    query = data.get("query") if data else None

    if not query:
        return jsonify({"error": "No search query provided"}), 400

    app.logger.info(f"Received text query: {query}")
    try:
        results = search_text(query, topk=5)  # ✅ now works like image search
        app.logger.info(f"Returning {len(results)} text results")
    except Exception as e:
        app.logger.error(f"{e}")
        return jsonify({"error": str(e)}), 500

    return jsonify(results)

# -----------------------------
# Booking Save API
# -----------------------------
@app.route("/save_booking", methods=["POST"])
def save_booking():
    data = request.get_json()
    if not data:
        return jsonify({"error": "No data received"}), 400

    # Attach the search info (front-end may send productImage OR productResult)
    product = data.get("productResult", {})  # object from search result (optional)

    # Prefer productImage sent directly, fallback:
    product_image_str = (data.get("productImage")
                         or product.get("image_url")
                         or product.get("uploaded_image")
                         or "")

    saved_data = {
        "name": data.get("name"),
        "email": data.get("email"),
        "phone": data.get("phone"),
        "location": data.get("location"),
        "chest": data.get("chest"),
        "waist": data.get("waist"),
        "shoulder": data.get("shoulder"),
        "sleeve": data.get("sleeve"),
        "selected Size": data.get("selectedSize"),
        "product Image": product_image_str,
        "search Query": (product.get("search_query") or data.get("searchQuery") or ""),
        "designer ID/Employee ID ": data.get("designerID"),
        "designer Name": data.get("designerName")
    }

    if os.path.exists(BOOKING_FILE):
        with open(BOOKING_FILE, "r", encoding="utf-8") as f:
            try:
                bookings = json.load(f)
            except json.JSONDecodeError:
                bookings = []
    else:
        bookings = []
    
    save_output_to_dataset(saved_data) 
    """    
    bookings.append(saved_data)
    # with open(BOOKING_FILE, "w", encoding="utf-8") as f:
    #     json.dump(bookings, f, indent=2, ensure_ascii=False)
    
    print("sssssssssssssssssssssssssss",saved_data)
    subject = f"New Task Assigned: {saved_data.get('name')}"

    # -----------------------------
    # Telegram message & photo sending
    # -----------------------------
    global bot_token, chat_id
    message = (
        f"📢 *New Task Assignment* 📢\n\n"
        f"Hello {saved_data.get('designer Name')},\n\n"
        f"Assigned Designer: {saved_data.get('designer Name')} (Employee ID: {saved_data.get('designer ID/Employee ID ')})\n\n"
        f"A new customer request has been assigned to you automatically by our system.\n\n"
        f"--- 👤 Customer Details ---\n"
        f"Name: {saved_data.get('name')}\n"
        f"Email: {saved_data.get('email')}\n"
        f"Phone: {saved_data.get('phone')}\n"
        f"Location: {saved_data.get('location')}\n\n"
        f"--- 📐 Measurements ---\n"
        f"Chest: {saved_data.get('chest')} in\n"
        f"Waist: {saved_data.get('waist')} in\n"
        f"Shoulder: {saved_data.get('shoulder')} in\n"
        f"Sleeve: {saved_data.get('sleeve')} in\n"
        f"Selected Size: {saved_data.get('selected Size')}\n\n"
        f"--- 🛍️ Product Details ---\n"
        f"Search Query: {saved_data.get('search Query')}\n\n"
        f"--- 🆔 Assignment Info ---\n"
        f"Task generated automatically by system bot.\n\n"
        f"If you have any queries, please reach out to Krish (Team Lead).\n\n"
        f"⚡ Please proceed with this task at your earliest convenience.\n\n"
        f"Thank you! 🙌"
    )
    body = message"""

    
 # TELEGRAM_BOT
    
    """
    if product_image_str:
        try:
            # Data URI
            if product_image_str.startswith("data:"):
                header, b64data = product_image_str.split(",", 1)
                img_bytes = base64.b64decode(b64data)
                mime = "image/jpeg"
                try:
                    mime = header.split(";")[0].split(":")[1]
                except Exception:
                    pass
                ext = mimetypes.guess_extension(mime) or ".jpg"
                filename = f"photo{ext}"
                bio = io.BytesIO(img_bytes)
                bio.name = filename
                files = {'photo': (filename, bio, mime)}
                resp = requests.post(
                    f'https://api.telegram.org/bot{bot_token}/sendPhoto',
                    data={'chat_id': chat_id, 'caption': f"Product image for {message}"},
                    files=files,
                    timeout=30
                )
                if resp.status_code != 200:
                    app.logger.error("Telegram sendPhoto (data URI) failed: %s %s", resp.status_code, resp.text)
            # HTTP(S) URL
            elif product_image_str.startswith("http://") or product_image_str.startswith("https://"):
                resp = requests.post(
                    f'https://api.telegram.org/bot{bot_token}/sendPhoto',
                    data={'chat_id': chat_id, 'photo': product_image_str, 'caption': f"Product image for {saved_data.get('name')}"},
                    timeout=15
                )
                if resp.status_code != 200:
                    app.logger.error("Telegram sendPhoto (URL) returned %s: %s", resp.status_code, resp.text)
                    requests.get(
                        f'https://api.telegram.org/bot{bot_token}/sendMessage',
                        params={'chat_id': chat_id, 'text': message},
                        timeout=10
                    )
            # Local file or path
            else:
                candidates = [
                    product_image_str,
                    os.path.join(os.getcwd(), product_image_str),
                    os.path.join(os.getcwd(), UPLOAD_FOLDER, os.path.basename(product_image_str)),
                    os.path.join(os.getcwd(), 'images', os.path.basename(product_image_str))
                ]
                found = None
                for p in candidates:
                    if p and os.path.exists(p):
                        found = p
                        break
                if found:
                    with open(found, 'rb') as photo_f:
                        filename = os.path.basename(found)
                        mime = mimetypes.guess_type(found)[0] or 'application/octet-stream'
                        files = {'photo': (filename, photo_f, mime)}
                        resp = requests.post(
                            f'https://api.telegram.org/bot{bot_token}/sendPhoto',
                            data={'chat_id': chat_id, 'caption': f"Product image for {saved_data.get('name')}"},
                            files=files,
                            timeout=30
                        )
                    if resp.status_code != 200:
                        app.logger.error("Telegram sendPhoto (local) returned %s: %s", resp.status_code, resp.text)
                else:
                    try:
                        base = request.host_url.rstrip('/')
                        photo_url = base + '/' + product_image_str.lstrip('/')
                        resp = requests.post(
                            f'https://api.telegram.org/bot{bot_token}/sendPhoto',
                            data={'chat_id': chat_id, 'photo': photo_url, 'caption': f"Product image for {saved_data.get('name')}"},
                            timeout=15
                        )
                        if resp.status_code != 200:
                            app.logger.error("Telegram sendPhoto (fallback URL) returned %s: %s", resp.status_code, resp.text)
                    except Exception as e:
                        app.logger.error("Telegram fallback URL attempt failed: %s", e)
        except Exception as e:
            app.logger.exception("Telegram photo send failed: %s", e)
    else:
        requests.get(
            f'https://api.telegram.org/bot{bot_token}/sendMessage',
            params={'chat_id': chat_id, 'text': message},
            timeout=10
        )
    # Send email
    email_sent = send_email("[email protected]", subject, body, product_image_str)
    if not email_sent:
        return jsonify({"error": "Booking saved but email failed"}), 500
    """

    return jsonify({"message": "Booking successfully saved"})

# -----------------------------
# Serve Static Files
# -----------------------------
@app.route("/optimized/<path:filename>")
def serve_images(filename):
    return send_from_directory("images", filename)

@app.route("/uploads/<path:filename>")
def serve_uploads(filename):
    return send_from_directory(UPLOAD_FOLDER, filename)

# -----------------------------
# Run App
# -----------------------------
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 5000)), debug=True)