# resume_screening_agent.py — AI-агент скрининга резюме
import os
from openai import OpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from pypdf import PdfReader

# Инициализация клиентов
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

def parse_resume(filepath: str) -> str:
    """Извлечение текста из PDF-резюме и структурирование через LLM."""
    reader = PdfReader(filepath)
    raw_text = "\n".join(p.extract_text() for p in reader.pages)

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": "Извлеки из резюме: навыки, опыт (годы), "
                         "должности, образование, сертификаты. Верни JSON."
        }, {"role": "user", "content": raw_text}]
    )
    return response.choices[0].message.content

def build_candidate_index(resume_dir: str):
    """Строит векторный индекс всех кандидатов в ChromaDB."""
    docs = []
    for fname in os.listdir(resume_dir):
        if fname.endswith(".pdf"):
            parsed = parse_resume(os.path.join(resume_dir, fname))
            docs.append({"content": parsed, "source": fname})

    texts = [d["content"] for d in docs]
    metadatas = [{"source": d["source"]} for d in docs]

    return Chroma.from_texts(
        texts=texts,
        embedding=embeddings,
        metadatas=metadatas,
        persist_directory="./chroma_hr_db"
    )

def match_candidates(job_description: str, k=10):
    """Семантический поиск топ-K кандидатов под вакансию."""
    db = Chroma(
        persist_directory="./chroma_hr_db",
        embedding_function=embeddings
    )
    results = db.similarity_search_with_score(
        query=job_description, k=k
    )
    return [(r.metadata["source"], round(score, 3))
            for r, score in results]

# Пример использования
if __name__ == "__main__":
    jd = """Senior ML Engineer: Python, PyTorch, Kubernetes,
           опыт deployment'а моделей, MLOps, 5+ лет."""
    matches = match_candidates(jd)
    for name, score in matches:
        print(f"{name} → score: {score}")
    

# voice_interview_agent.py — голосовой AI-интервьюер
import asyncio, json
from openai import AsyncOpenAI

client = AsyncOpenAI()

# Рубрикатор оценки ответов кандидата
RUBRIC = {
    "technical_depth":  "Глубина технического ответа (1-5)",
    "clarity":          "Ясность и структура ответа (1-5)",
    "relevant_examples": "Наличие релевантных примеров (1-5)",
    "communication":      "Коммуникативные навыки (1-5)",
}

async def transcribe_audio(audio_path: str) -> str:
    """Whisper: голос → текст."""
    with open(audio_path, "rb") as f:
        transcript = await client.audio.transcriptions.create(
            model="whisper-1", file=f
        )
    return transcript.text

async def evaluate_answer(question: str, answer: str, context: dict) -> dict:
    """Оценка ответа по рубрикатору через LLM."""
    prompt = f"""Оцени ответ кандидата на вопрос интервью.
Вопрос: {question}
Ответ кандидата: {answer}
Должность: {context.get('role', 'N/A')}

Оцени по шкале 1-5 для каждого критерия:
{json.dumps(RUBRIC, indent=2, ensure_ascii=False)}

Верни JSON: {{"technical_depth": N, "clarity": N, ...}}"""

    resp = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "system", "content": prompt}],
        response_format={"type": "json_object"}
    )
    return json.loads(resp.choices[0].message.content)

async def generate_next_question(history: list, level: str) -> str:
    """Динамическая генерация следующего вопроса."""
    resp = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": f"Ты AI-интервьюер уровня {level}. "
                         "Задай следующий вопрос кандидату."
        }, {"role": "user", "content": json.dumps(history)}]
    )
    return resp.choices[0].message.content

# Полный цикл интервью
async def run_interview(candidate_audio_dir: str, role):
    history = []
    questions = [
        "Расскажите о вашем самом сложном проекте.",
        "Какие технологии вы выбрали и почему?",
        "Как вы решали конфликты в команде?",
    ]
    for i, q in enumerate(questions):
        audio_file = f"{candidate_audio_dir}/answer_{i}.mp3"
        answer_text = await transcribe_audio(audio_file)
        scores = await evaluate_answer(q, answer_text, {"role": role})
        history.append({"q": q, "a": answer_text, "scores": scores})
    return history
    

# onboarding_agent.py — AI-агент онбординга с RAG
from langchain_community.document_loaders import NotionDirectoryLoader
from langchain_community.vectorstores import Pinecone
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.chains import RetrievalQA

llm = ChatOpenAI(model="gpt-4o", temperature=0.1)
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

# Загрузка корпоративной Wiki в Pinecone
def build_knowledge_base():
    loader = NotionDirectoryLoader("./company_wiki")
    docs = loader.load()
    return Pinecone.from_documents(
        docs, embeddings,
        index_name="onboarding-kb"
    )

# RAG-цепочка: поиск + генерация ответа
def create_onboarding_agent():
    vectorstore = build_knowledge_base()
    return RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vectorstore.as_retriever(search_kwargs={"k": 5})
    )

# CLI-команда для создания учёток через Okta API
# curl -X POST https://${OKTA_DOMAIN}/api/v1/users \
#   -H "Authorization: SSWS ${OKTA_API_TOKEN}" \
#   -H "Content-Type: application/json" \
#   -d '{"profile":{"firstName":"Иван","lastName":"Петров",
#        "email":"ivan@company.com","login":"ivan@company.com"}}'

echo "Пользователь создан в Okta: ivan@company.com"
    

# ats_integration.py — интеграция с Greenhouse API
import os, requests, base64
from fastapi import FastAPI, Request

GREENHOUSE_API = "https://harvest.greenhouse.io/v1"
API_KEY = os.getenv("GREENHOUSE_API_KEY")
auth_header = {"Authorization": f"Basic {base64.b64encode(f'{API_KEY}:'.encode()).decode()}"}

app = FastAPI()

def get_candidate(candidate_id: int) -> dict:
    """Получение карточки кандидата из Greenhouse."""
    resp = requests.get(
        f"{GREENHOUSE_API}/candidates/{candidate_id}",
        headers=auth_header
    )
    return resp.json()

def update_candidate_field(candidate_id: int, field: str, value):
    """Обновление custom-поля кандидата (ai_fit_score, etc)."""
    payload = {"custom_fields": {field: value}}
    return requests.patch(
        f"{GREENHOUSE_API}/candidates/{candidate_id}",
        headers={**auth_header, "Content-Type": "application/json"},
        json=payload
    )

# Webhook-эндпоинт для событий Greenhouse
@app.post("/webhook/greenhouse")
async def greenhouse_webhook(request: Request):
    event = await request.json()
    if event["action"] == "candidate_created":
        cid = event["payload"]["candidate"]["id"]
        # Запуск AI-скрининга (match_candidates из секции #1)
        import resume_screening_agent
        candidate = get_candidate(cid)
        score = resume_screening_agent.score_candidate(candidate)
        update_candidate_field(cid, "ai_fit_score", score)
        return {"status": "scored", "candidate_id": cid, "ai_fit_score": score}
    return {"status": "ignored"}
    

# Сравнение API-доступа и кастомизации
# Eightfold: REST API + Talent Graph
curl -X GET "https://api.eightfold.ai/v2/talent/search" \
     -H "Authorization: Bearer $EIGHTFOLD_TOKEN" \
     -d '{"skills":["Python","PyTorch"],"experience_years":{"min":3}}'

# Lever API: создание кандидата
curl -X POST "https://api.lever.co/v1/opportunities" \
     -u "$LEVER_API_KEY:" \
     -d '{"name":"Анна Смирнова","emails":["anna@example.com"],
      "posting":"ml-engineer-2026"}'

# Moonhub: инициализация AI-поиска
python3 moonhub_cli.py --role "Senior DevOps" \
                   --skills "Kubernetes,Terraform,AWS" \
                   --max-candidates 50 --auto-outreach
    

# SQL-запрос для Metabase/Grafana: воронка кандидатов с AI-скорингом
SELECT
  date_trunc('week', c.created_at) AS week,
  COUNT(*) AS total_candidates,
  AVG(c.ai_fit_score) AS avg_ai_score,
  COUNT(CASE WHEN c.stage = 'offer_accepted' THEN 1 END) AS hires,
  ROUND(
    COUNT(CASE WHEN c.stage = 'offer_accepted' THEN 1 END)::numeric / COUNT(*) * 100, 1
  ) AS conversion_rate_pct
FROM candidates c
WHERE c.created_at >= NOW() - INTERVAL '90 days'
GROUP BY 1 ORDER BY 1 DESC;