app.py

import os
os.environ["OMP_NUM_THREADS"] = "1"

import re
import json
import datetime as dt
from urllib.parse import urlparse
import xml.etree.ElementTree as ET

import requests
import gradio as gr
from utils import extract_kyc_fields

# ------------------ HARD-CODED SALESFORCE CREDS (as requested) ------------------
SF_USERNAME = "[email protected]"
SF_PASSWORD = "Lic@2025"
SF_SECURITY_TOKEN = "AmmfRcd6IiYaRtSGntBnzNMQU"
SF_DOMAIN = "login"   # "login" for prod, "test" for sandbox
SF_API_VERSION = "60.0"  # safe current Partner/REST version
# -------------------------------------------------------------------------------


# ---------- helpers ----------
def _parse_birthdate(dob_text: str):
    """
    Normalize DOB to YYYY-MM-DD (Salesforce Date).
    Supports dd/mm/yyyy, dd-mm-yyyy, dd.mm.yyyy, yyyy-mm-dd, or just YYYY (mapped to mid-year).
    """
    if not dob_text or dob_text == "Not found":
        return None
    s = dob_text.strip()

    m = re.fullmatch(r"(\d{4})-(\d{2})-(\d{2})", s)
    if m:
        y, mo, d = map(int, m.groups())
        try:
            return dt.date(y, mo, d).isoformat()
        except ValueError:
            return None

    m = re.fullmatch(r"(\d{2})[./-](\d{2})[./-](\d{4})", s)
    if m:
        d, mo, y = map(int, m.groups())
        try:
            return dt.date(y, mo, d).isoformat()
        except ValueError:
            return None

    m = re.fullmatch(r"(19|20)\d{2}", s)
    if m:
        y = int(s)
        try:
            return dt.date(y, 6, 15).isoformat()
        except ValueError:
            return None

    return None


def _soap_login(username: str, password: str, token: str, domain: str = "login", api_version: str = SF_API_VERSION):
    """
    Login via Salesforce Partner SOAP API (no connected app needed).
    Returns (instance_url, access_token) on success; raises on error.
    """
    endpoint = f"https://{domain}.salesforce.com/services/Soap/u/{api_version}"
    combined_password = f"{password}{token}"

    envelope = f"""<?xml version="1.0" encoding="utf-8" ?>
<env:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
  <env:Body>
    <n1:login xmlns:n1="urn:partner.soap.sforce.com">
      <n1:username>{username}</n1:username>
      <n1:password>{combined_password}</n1:password>
    </n1:login>
  </env:Body>
</env:Envelope>"""

    headers = {
        "Content-Type": "text/xml; charset=UTF-8",
        "SOAPAction": "login",
    }

    resp = requests.post(endpoint, data=envelope.encode("utf-8"), headers=headers, timeout=30)
    if resp.status_code != 200:
        raise RuntimeError(f"SOAP login HTTP {resp.status_code}: {resp.text[:400]}")

    # Parse XML to find sessionId and serverUrl
    try:
        root = ET.fromstring(resp.text)
    except ET.ParseError as e:
        raise RuntimeError(f"SOAP login parse error: {e}")

    # Find tags by localname to avoid namespace headaches
    session_id = None
    server_url = None
    for elem in root.iter():
        tag = elem.tag.split('}', 1)[-1]  # strip namespace
        if tag == "sessionId":
            session_id = elem.text
        elif tag == "serverUrl":
            server_url = elem.text

    if not session_id or not server_url:
        raise RuntimeError(f"SOAP login failed: sessionId/serverUrl not found. Raw: {resp.text[:600]}")

    parsed = urlparse(server_url)
    instance_url = f"{parsed.scheme}://{parsed.netloc}"
    return instance_url, session_id


def _rest_create(instance_url: str, access_token: str, object_api: str, payload: dict, api_version: str = SF_API_VERSION):
    """
    Create a record via REST API. Returns a dict with success flag and details.
    """
    url = f"{instance_url}/services/data/v{api_version}/sobjects/{object_api}"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json",
    }
    resp = requests.post(url, headers=headers, data=json.dumps(payload), timeout=30)

    try:
        body = resp.json()
    except Exception:
        body = None

    if 200 <= resp.status_code < 300:
        rec_id = body.get("id") if isinstance(body, dict) else None
        return {"success": True, "id": rec_id, "status_code": resp.status_code, "url": url, "response_json": body}
    else:
        # Salesforce error lists come back as JSON arrays usually
        return {
            "success": False,
            "status_code": resp.status_code,
            "url": url,
            "response_json": body,
            "response_text": resp.text,
        }


def sf_push_kyc_record(ocr_results: dict):
    """
    Combine Aadhaar + PAN into one KYC_Record__c and create via REST.
    Fields expected in SF (API names):
      Aadhaar_Number__c, Aadhaar_Name__c, Aadhaar_DOB__c (Date)
      PAN_Number__c,    Pan_Name__c,     Pan_DOB__c     (Date)
    """
    a = ocr_results.get("aadhaar") or {}
    p = ocr_results.get("pan") or {}

    aadhaar_number = a.get("aadhaar_number") if (a.get("card_type") == "AADHAAR") else None
    aadhaar_name   = a.get("name")           if (a.get("card_type") == "AADHAAR") else None
    aadhaar_dob    = _parse_birthdate(a.get("dob")) if (a.get("card_type") == "AADHAAR") else None

    pan_number     = p.get("pan_number") if (p.get("card_type") == "PAN") else None
    pan_name       = p.get("name")       if (p.get("card_type") == "PAN") else None
    pan_dob        = _parse_birthdate(p.get("dob")) if (p.get("card_type") == "PAN") else None

    payload = {
        "Aadhaar_Number__c": aadhaar_number,
        "Aadhaar_Name__c":   aadhaar_name,
        "Aadhaar_DOB__c":    aadhaar_dob,
        "PAN_Number__c":     pan_number,
        "Pan_Name__c":       pan_name,
        "Pan_DOB__c":        pan_dob,
    }
    payload = {k: v for k, v in payload.items() if v is not None}

    # 1) SOAP login
    instance_url, access_token = _soap_login(SF_USERNAME, SF_PASSWORD, SF_SECURITY_TOKEN, SF_DOMAIN, SF_API_VERSION)
    # 2) REST create
    return _rest_create(instance_url, access_token, "KYC_Record__c", payload, SF_API_VERSION)


# ---------- gradio callback ----------
def process_documents(aadhaar_file, pan_file, push_to_sf):
    """
    - Runs OCR on Aadhaar and PAN separately.
    - Optionally pushes a single KYC_Record__c to Salesforce via SOAP+REST (no simple-salesforce).
    """
    results = {"aadhaar": None, "pan": None}

    if not aadhaar_file and not pan_file:
        return {"error": "Please upload at least one file (Aadhaar and/or PAN)."}

    # OCR Aadhaar
    if aadhaar_file:
        try:
            res = extract_kyc_fields(aadhaar_file.name)
            res["source_file"] = os.path.basename(aadhaar_file.name)
            results["aadhaar"] = res
        except Exception as e:
            results["aadhaar"] = {"error": f"Aadhaar OCR failed: {str(e)}", "card_type": "UNKNOWN"}

    # OCR PAN
    if pan_file:
        try:
            res = extract_kyc_fields(pan_file.name)
            res["source_file"] = os.path.basename(pan_file.name)
            results["pan"] = res
        except Exception as e:
            results["pan"] = {"error": f"PAN OCR failed: {str(e)}", "card_type": "UNKNOWN"}

    output = {"ocr": results}

    if push_to_sf:
        try:
            created = sf_push_kyc_record(results)
            output["salesforce"] = {"pushed": created.get("success", False), **created}
        except Exception as e:
            output["salesforce"] = {"pushed": False, "error": {"type": e.__class__.__name__, "message": str(e)}}

    return output


# ---------- UI ----------
with gr.Blocks(title="Smart KYC OCR → Salesforce (KYC_Record__c)") as demo:
    gr.Markdown(
        """
        # 🧾 Smart KYC OCR → Salesforce
        Upload **Aadhaar** and **PAN** in separate boxes, then (optional) push one **KYC_Record__c**.
        """
    )

    with gr.Row():
        with gr.Column(scale=1):
            aadhaar_uploader = gr.File(
                label="📤 Aadhaar Upload",
                file_types=[".jpg", ".jpeg", ".png"]
            )
        with gr.Column(scale=1):
            pan_uploader = gr.File(
                label="📤 PAN Upload",
                file_types=[".jpg", ".jpeg", ".png"]
            )

    push_to_sf = gr.Checkbox(label="Push to Salesforce (create KYC_Record__c)", value=False)

    submit_btn = gr.Button("🔍 Extract KYC Info", variant="primary")
    output_json = gr.JSON(label="📋 Output (OCR + Salesforce)")

    submit_btn.click(
        fn=process_documents,
        inputs=[aadhaar_uploader, pan_uploader, push_to_sf],
        outputs=output_json,
    )

    gr.Markdown("---")
    gr.Markdown(
        """
        You’ll see `status_code`, `url`, and Salesforce’s `response_json` on errors (e.g., wrong field API name or permissions).
        """
    )

# Keep `demo` at module level for Spaces too
if __name__ == "__main__":
    demo.launch()