# =============================================================================
# Job·Ka — Groupe KA
# Auteur  : Simon-Pierre Boucher
# Contact : contact@spboucher.ai
# Fichier : jobka/connectors/taleo.py
# Rôle    : Classe de plateforme Oracle Taleo Enterprise (careersection REST)
#           — un employeur = une sous-classe (HOST, SECTION, EMPLOYER)
# Créé    : 2026-08-18   Modifié : 2026-09-09
# =============================================================================
"""Plateforme Oracle Taleo Enterprise.

Les sections carrières Taleo exposent une API REST publique (celle que le
frontal jobsearch.ftl consomme lui-même) :
- amorce : GET  https://<host>.taleo.net/careersection/<section>/jobsearch.ftl
           (cookies de session + numéro de portail « portal=NNN » dans le HTML)
- liste  : POST https://<host>.taleo.net/careersection/rest/jobboard/searchjobs
           ?lang=fr&portal=<NNN>  body JSON {pageNo, sorting…}
           -> {requisitionList:[{jobId, contestNo, column:[...],
               locationsColumns:[i]}], pagingData:{totalCount, pageSize}}
- détail : la page jobdetail.ftl?job=<contestNo> (description HTML rendue
           côté serveur) — visitée avec cache BD et budget.

Le contenu des colonnes dépend de la configuration du portail : on repère la
colonne des lieux via `locationsColumns` et on suppose la première colonne
comme titre (constaté sur tous les portails testés).
"""
from __future__ import annotations

import hashlib
import json
import os
import re
import time

import requests

from ..normalize import parse_date
from ..schema import JobPosting, clean_html, is_quebec_location
from .base import BaseConnector

MAX_DETAILS = int(os.environ.get("JOBKA_TALEO_DETAIL_LIMIT", "120"))

_DESC_RE = re.compile(
    r'requisitionDescriptionInterface[^>]*>', re.I)


class TaleoConnector(BaseConnector):
    """Base Taleo — sous-classes : définir source_id, EMPLOYER, HOST, SECTION
    (et PORTAL si le numéro n'apparaît pas dans le HTML d'amorce)."""

    ats = "taleo"
    request_delay = 1.0

    EMPLOYER = ""
    HOST = ""              # <host>.taleo.net
    SECTION = "2"          # /careersection/<section>/
    PORTAL = ""            # numéro de portail (sinon extrait du HTML)
    LANG = "fr"
    quebec_only = True
    max_pages = 40
    # La dernière colonne du tableau searchjobs dépend de la configuration du
    # portail : date d'affichage (« posted ») pour la plupart, mais DATE
    # LIMITE (« deadline ») chez certains (agnico_eagle). Une date future est
    # de toute façon toujours traitée comme date limite (une date de
    # publication ne peut pas être dans le futur).
    DATE_COL = "posted"    # posted | deadline

    @property
    def _base(self) -> str:
        return f"https://{self.HOST}.taleo.net/careersection"

    def _req(self, method: str, url: str, **kwargs) -> requests.Response:
        # Les frontaux Taleo renvoient à l'occasion un 5xx isolé qui repart
        # seul (500 constaté le 2026-09-08 23h29 sur textron/searchjobs) :
        # raise_for_status dans base.get/post faisait échouer tout le sync.
        # On retente avec backoff sur 5xx ; les 4xx restent des échecs
        # immédiats (même correctif que la plateforme Workday, b5b4be3).
        last: requests.HTTPError | None = None
        for attempt in range(3):
            try:
                return (self.post if method == "post" else self.get)(
                    url, **kwargs)
            except requests.HTTPError as exc:
                if exc.response is None or exc.response.status_code < 500:
                    raise
                last = exc
                time.sleep(10 * (attempt + 1))
        raise RuntimeError(f"Taleo 5xx après 3 essais : {last}")

    def _search_page(self, url: str, body: dict) -> dict:
        # Le frontal Taleo renvoie à l'occasion une page HTML avec statut 200
        # au lieu du JSON de searchjobs (session expirée ou interstitiel
        # passager — « Expecting value: line 2 column 1 » constaté le
        # 2026-09-09 06h29 sur bayshore, reparti seul) : aucun retry existant
        # ne couvre ce cas (le corps n'est pas un 5xx ni un blocage). On
        # retente avec backoff en ré-amorçant la session (nouveaux cookies).
        for attempt in range(3):
            resp = self._req("post", url, json=body,
                             headers={"tz": "GMT-04:00"})
            try:
                return resp.json()
            except ValueError:
                if attempt == 2:
                    snippet = (resp.text or "")[:120].replace("\n", " ")
                    raise RuntimeError(
                        f"taleo {self.HOST}: searchjobs non-JSON après 3 "
                        f"essais (statut {resp.status_code}) : {snippet!r}")
                time.sleep(10 * (attempt + 1))
                self._bootstrap()

    def _careers_url(self) -> str:
        return f"{self._base}/{self.SECTION}/jobsearch.ftl?lang={self.LANG}"

    def _bootstrap(self) -> str:
        """Cookies de session + numéro de portail."""
        html = self._req("get", self._careers_url()).text
        if self.PORTAL:
            return str(self.PORTAL)
        m = re.search(r"portal=(\d+)", html)
        if not m:
            raise RuntimeError(f"taleo {self.HOST}: numéro de portail introuvable")
        return m.group(1)

    @staticmethod
    def _parse_locations(raw: str) -> list[str]:
        """La colonne des lieux est un JSON sérialisé : '["Québec-Malartic"]'."""
        if not raw:
            return []
        try:
            val = json.loads(raw)
            if isinstance(val, list):
                return [str(v) for v in val]
        except ValueError:
            pass
        return [raw]

    def _keep(self, locations: list[str]) -> bool:
        if not self.quebec_only:
            return True
        return any(is_quebec_location(l.replace("-", " ")) for l in locations)

    def _fetch_detail(self, contest_no: str) -> dict:
        html = self._req("get", f"{self._base}/{self.SECTION}/jobdetail.ftl",
                         params={"job": contest_no, "lang": self.LANG}).text
        # description : contenu des blocs « requisitionDescriptionInterface »
        # (rendus côté serveur), sinon la zone principale de la page
        chunks = re.findall(
            r'<(?:span|div)[^>]*id="requisitionDescriptionInterface[^"]*"[^>]*>'
            r"(.*?)</(?:span|div)>", html, re.S)
        text = clean_html("\n".join(c for c in chunks if len(c) > 40))
        if not text:
            m = re.search(r'<div[^>]*class="[^"]*mastercontentpanel[^"]*"[^>]*>'
                          r"(.*?)<!--", html, re.S)
            text = clean_html(m.group(1)) if m else ""
        return {"description": text}

    def fetch(self) -> list[JobPosting]:
        portal = self._bootstrap()
        url = (f"{self._base}/rest/jobboard/searchjobs"
               f"?lang={self.LANG}&portal={portal}")
        body_base = {
            "multilineEnabled": False,
            "sortingSelection": {"sortBySelectionParam": "3",
                                 "ascendingSortingOrder": "false"},
            "fieldData": {"fields": {"KEYWORD": "", "LOCATION": ""},
                          "valid": True},
            "filterSelectionParam": {"searchFilterSelections": [
                {"id": "POSTING_DATE", "selectedValues": []},
                {"id": "LOCATION", "selectedValues": []}]},
            "advancedSearchFiltersSelectionParam":
                {"searchFilterSelections": []},
        }
        out: list[JobPosting] = []
        details_used = 0
        page = 1
        seen: set[str] = set()
        while page <= self.max_pages:
            data = self._search_page(url, {**body_base, "pageNo": page})
            reqs = data.get("requisitionList") or []
            if not reqs and page == 1 and self.LANG != "en":
                # section carrières anglophone seulement : rebasculer en « en »
                self.LANG = "en"
                portal = self._bootstrap()
                url = (f"{self._base}/rest/jobboard/searchjobs"
                       f"?lang={self.LANG}&portal={portal}")
                continue
            if not reqs:
                break
            for r in reqs:
                cols = r.get("column") or []
                loc_idx = (r.get("locationsColumns") or [1])[0]
                title = str(cols[0]) if cols else ""
                locations = self._parse_locations(
                    str(cols[loc_idx])) if len(cols) > loc_idx else []
                date_raw = str(cols[-1]) if len(cols) > 2 else ""
                contest = str(r.get("contestNo") or r.get("jobId") or "")
                if not contest or contest in seen or not title:
                    continue
                seen.add(contest)
                if not self._keep(locations):
                    continue
                # colonne date : publication ou date limite selon le portail ;
                # une date FUTURE est toujours une date limite (jamais une
                # date de publication) — correctif du bogue agnico_eagle
                date_posted = date_deadline = None
                iso = parse_date(date_raw) if date_raw else None
                if iso:
                    import datetime as _dt
                    if (self.DATE_COL == "deadline"
                            or iso > _dt.date.today().isoformat()):
                        date_deadline = iso
                    else:
                        date_posted = iso
                job = JobPosting(
                    source=self.source_id, external_id=contest,
                    url=(f"{self._base}/{self.SECTION}/jobdetail.ftl"
                         f"?job={contest}&lang={self.LANG}"),
                    employer=self.EMPLOYER,
                    title=title,
                    location_label=locations[0].replace("-", ", ")
                    if locations else "",
                    date_posted=date_posted, date_deadline=date_deadline,
                    ats=self.ats,
                )
                key = hashlib.sha1(
                    f"{title}|{date_raw}".encode()).hexdigest()[:12]
                if details_used < MAX_DETAILS:
                    fresh = [False]

                    def _fn(c=contest, fresh=fresh):
                        fresh[0] = True
                        return self._fetch_detail(c)

                    d = self.detail(contest, key, _fn)
                    if fresh[0]:
                        details_used += 1
                    job.description = d.get("description", "")
                out.append(job)
            paging = data.get("pagingData") or {}
            total = int(paging.get("totalCount") or 0)
            size = int(paging.get("pageSize") or len(reqs) or 25)
            if total and page * size >= total:
                break
            page += 1
        return out