app.py

import os
import json
import re
from flask import Flask, jsonify, render_template, request
from dotenv import load_dotenv

from google import genai
from google.genai import types

load_dotenv()
app = Flask(__name__)

DEFAULT_MODEL = "gemini-2.5-flash"
ALLOWED_MODELS = {"gemini-2.5-flash", "gemini-2.5-flash-preview", "gpt-4o-mini"}


def _extract_json(text: str) -> dict:
    t = (text or "").strip()
    t = re.sub(r"^```(?:json)?\s*", "", t)
    t = re.sub(r"\s*```$", "", t)
    if not t.startswith("{"):
        m = re.search(r"\{.*\}", t, re.S)
        if m:
            t = m.group(0)
    return json.loads(t)


def _normalize_phone(phone: str | None) -> str | None:
    if not phone:
        return None
    digits = re.sub(r"\D+", "", phone)
    if len(digits) == 11 and digits.startswith("1"):
        digits = digits[1:]
    if len(digits) == 10:
        return f"{digits[0:3]}-{digits[3:6]}-{digits[6:10]}"
    return phone.strip()


def get_text_and_llm():
    payload = request.get_json(silent=True) or {}
    text = payload.get("text")
    llm = payload.get("llm")

    if not text:
        text = request.form.get("text")
    if not llm:
        llm = request.form.get("llm")

    if not text:
        text = request.args.get("text")
    if not llm:
        llm = request.args.get("llm")

    if not text:
        raw = request.get_data(as_text=True) or ""
        raw = raw.strip()
        if raw and raw[0] != "{":
            text = raw

    llm = llm or DEFAULT_MODEL
    if llm not in ALLOWED_MODELS:
        llm = DEFAULT_MODEL

    return (text or "").strip(), llm


def call_gemini_extract(text: str, model: str) -> dict:
    api_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
    if not api_key:
        raise RuntimeError("Missing GEMINI_API_KEY (or GOOGLE_API_KEY).")

    client = genai.Client(api_key=api_key)

    prompt = f"""
Extract contact information from the given text.
Return a JSON object with these fields:
- name: The person's full name (string or null)
- email: The email address (string or null)
- phone: The phone number (string or null)

Rules:
- Only extract what is explicitly present. Do NOT guess.
- Return ONLY the JSON object. No markdown. No explanations.

Text:
{text}
""".strip()

    resp = client.models.generate_content(
        model=model if model.startswith("gemini") else DEFAULT_MODEL,
        contents=prompt,
        config=types.GenerateContentConfig(
            temperature=0,
            max_output_tokens=256,
            response_mime_type="application/json",
        ),
    )

    data = _extract_json(resp.text)

    name = data.get("name")
    email = data.get("email")
    phone = data.get("phone")

    name = name.strip() if isinstance(name, str) and name.strip() else None
    email = email.strip() if isinstance(email, str) and email.strip() else None
    phone = _normalize_phone(phone if isinstance(phone, str) else None)

    return {"name": name, "email": email, "phone": phone}


@app.route("/")
def index():
    return render_template("index.html", default_model=DEFAULT_MODEL)


@app.route("/health", methods=["GET"])
def health():
    return jsonify({"status": "ok"})


@app.route("/parse", methods=["POST"])
def parse():
    text, llm = get_text_and_llm()

    if not text:
        return jsonify({"error": "Field 'text' is required"}), 400

    try:
        extracted = call_gemini_extract(text, llm)
        return jsonify({
            "name": extracted["name"],
            "email": extracted["email"],
            "phone": extracted["phone"],
            "found_in_database": False,
            "company": None,
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, debug=True)