process_data.py

import requests
import json
import time
import schedule
import os
import logging
from datetime import datetime
from dotenv import load_dotenv
from google.generativeai import GenerativeModel
import google.generativeai as genai
from PIL import Image
import pytesseract
from io import BytesIO

# --- Logging Ayarları ---
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)  # DEBUG seviyesini aktif hale getir

# Konsol için UTF-8 kodlamalı handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
console_handler.setStream(open(console_handler.stream.fileno(), mode='w', encoding='utf-8', errors='replace'))

# Dosya için handler
file_handler = logging.FileHandler("social_media_analyzer.log", encoding='utf-8')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))

# Handler'ları logger'a ekle
logger.handlers = [console_handler, file_handler]

# --- .env dosyasını yükle ---
load_dotenv()

# --- Ayarlar (dotenv ile) ---
GENAI_API_KEY = os.getenv("GENAI_API_KEY")
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
AUTH_TOKEN = os.getenv("AUTH_TOKEN")
SCRAPED_DATA_API = os.getenv("SCRAPED_DATA_API")
FILTERED_DATA_API = os.getenv("FILTERED_DATA_API")
MARK_USED_API = os.getenv("MARK_USED_API")
#pytesseract.pytesseract.tesseract_cmd = r"C:\Program Files\Tesseract-OCR\tesseract.exe"

# --- Gemini Model Ayarı ---
genai.configure(api_key=GENAI_API_KEY)
model = genai.GenerativeModel(model_name="models/gemini-1.5-pro-latest")

def validate_address(address):
    if not address:
        logger.warning("Adres boş, doğrulama atlandı.")
        return False, None, None

    url = "https://maps.googleapis.com/maps/api/geocode/json"
    params = {
        "address": address,
        "key": GOOGLE_API_KEY
    }
    try:
        response = requests.get(url, params=params, timeout=10)
        data = response.json()
        
        if data["status"] != "OK" or not data["results"]:
            logger.error(f"Google Maps Hatası: Status {data['status']}, Mesaj: {data.get('error_message', 'Bilinmeyen hata')}")
            return False, None, None

        result = data["results"][0]
        address_types = result.get("types", [])
        address_components = result.get("address_components", [])

        valid_types = ["street_address", "route", "premise"]
        if not any(t in valid_types for t in address_types):
            logger.warning(f"Adres çok genel: {address}, Türler: {address_types}")
            return False, None, None

        has_street = False
        has_street_number = False
        for component in address_components:
            if "route" in component["types"]:
                has_street = True
            if "street_number" in component["types"] or "subpremise" in component["types"]:
                has_street_number = True

        if not (has_street and has_street_number):
            logger.warning(f"Adres sokak veya numara/bina içermiyor: {address}")
            return False, None, None

        lat = result["geometry"]["location"]["lat"]
        lng = result["geometry"]["location"]["lng"]
        maps_link = f"https://www.google.com/maps/search/?api=1&query={lat},{lng}"

        logger.info(f"Adres doğrulandı: {address}, Türler: {address_types}, Komponentler: {address_components}, Maps Link: {maps_link}")
        return True, maps_link, (lat, lng)

    except Exception as e:
        logger.error(f"Google Maps Hatası: {e}")
        return False, None, None

def analyze_social_post(text):
    prompt = f"""
Aşağıdaki metin, sosyal medyada paylaşılmış bir içeriktir. Şu üç soruya yanıt ver:

1. Bu içerik bir doğal afet (deprem, yangın, sel, çökme, acil durum) ile ilgili mi?
   → Sadece "afet" ya da "diğer" yaz.
2. Eğer adres içeren bir ifade varsa, onu parçalara ayırarak aşağıdaki JSON formatında çıkar:
   {{
     "il": "Şehir adı",
     "ilce": "İlçe adı",
     "mahalle": "Mahalle adı",
     "cadde": "Cadde adı ya da null",
     "sokak": "Sokak adı ya da null",
     "no": "Bina numarası, apartman adı ya da blok adı"
   }}
   → Örnek: 
   {{
     "il": "İstanbul",
     "ilce": "Kadıköy",
     "mahalle": "Hasanpaşa Mahallesi",
     "cadde": "Uzunçayır Caddesi",
     "sokak": null,
     "no": "No:2"
   }}
3. İçerikte geçen olay/duygu/çağrı ne? Kısaca özetle.

Lütfen çıktıyı aşağıdaki JSON formatında ver:
{{
  "konu": "afet" | "diğer",
  "address": {{...}},
  "summary_note": "..."
}}

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

    try:
        response = model.generate_content(prompt)
        content = response.text.strip()

        if content.startswith("```json"):
            content = content.removeprefix("```json").strip()
        if content.endswith("```"):
            content = content.removesuffix("```").strip()

        data = json.loads(content, parse_constant=lambda x: None if x == "null" else x)

    except json.JSONDecodeError as e:
        logger.error(f"JSON parse hatası: {e}, Ham veri: {content}")
        return {"is_valid": False, "reason": f"JSON parse hatası: {e}", "raw": content}
    except Exception as e:
        logger.error(f"Gemini hatası: {e}")
        return {"is_valid": False, "reason": f"Gemini hatası: {e}"}

    if data.get("konu") != "afet":
        logger.info("Tweet afet dışı, atlanıyor.")
        return {"is_valid": False, "reason": "afet değil", **data}

    addr = data.get("address", {})
    # Adres alanlarının None olup olmadığını kontrol et ve string'e çevir
    il = str(addr.get("il", "")) if addr.get("il") is not None else ""
    ilce = str(addr.get("ilce", "")) if addr.get("ilce") is not None else ""
    mahalle = str(addr.get("mahalle", "")) if addr.get("mahalle") is not None else ""
    cadde = str(addr.get("cadde", "")) if addr.get("cadde") is not None else ""
    sokak = str(addr.get("sokak", "")) if addr.get("sokak") is not None else ""
    no = str(addr.get("no", "")) if addr.get("no") is not None else ""

    full_address = f"{il} {ilce} {mahalle} "
    if cadde:
        full_address += cadde + " "
    if sokak:
        full_address += sokak + " "
    full_address += no
    full_address = full_address.strip()

    if not full_address.strip():
        logger.info("Adres bulunamadı, afet verisi olarak işleniyor.")
        return {
            "is_valid": True,
            "reason": "afet verisi, adres yok",
            "address": data.get("address", {}),
            "summary_note": data.get("summary_note", ""),
            "address_link": "",
            "coordinates": []
        }

    is_valid, maps_link, coordinates = validate_address(full_address)
    if not is_valid:
        logger.warning("Adres geçersiz, tweet işlenemedi.")
        return {"is_valid": False, "reason": "adres geçersiz", **data}

    result = {
        "is_valid": True,
        "reason": "geçerli afet verisi",
        "address": data.get("address", {}),
        "summary_note": data.get("summary_note", ""),
        "address_link": maps_link,
        "coordinates": coordinates
    }
    logger.info("Tweet başarıyla işlendi.")
    return result

def image_to_text(image_url):
    try:
        response = requests.get(image_url)
        image = Image.open(BytesIO(response.content))
        text = pytesseract.image_to_string(image, lang='tur')
        logger.info(f"Görselden okunan metin: {text}")
        return text.strip()
    except Exception as e:
        logger.error(f"Görsel işleme hatası: {e}")
        return ""

def fetch_scraped_data():
    """
    GET /scraped-datas endpoint'inden ham verileri çeker.
    """
    logger.info("Veriler çekiliyor...")
    try:
        headers = {
            "Authorization": AUTH_TOKEN
        }
        response = requests.get(SCRAPED_DATA_API, headers=headers, timeout=10)
        
        # HTTP durum kodunu kontrol et
        if response.status_code != 200:
            logger.error(f"API isteği başarısız, Durum Kodu: {response.status_code}, Cevap: {response.text}")
            return []

        # JSON'a çevirmeye çalış
        try:
            data = response.json()
        except ValueError as e:
            logger.error(f"JSON parse hatası: {e}, Ham cevap: {response.text}")
            return []

        # Verinin bir liste olup olmadığını kontrol et
        if not isinstance(data, list):
            logger.error(f"Gelen veri bir liste değil, tipi: {type(data)}, içerik: {data}")
            return []

        # Veriyi doğru formata çevir
        formatted_data = []
        for item in data:
            # _id'yi scrapedDataId olarak eşle
            id_field = item.get("_id")
            
            if isinstance(id_field, dict):
                # Eğer _id bir dictionary ise (örneğin, {"$oid": "..."})
                scraped_data_id = id_field.get("$oid", None)
            elif isinstance(id_field, str):
                # Eğer _id bir string ise
                scraped_data_id = id_field
            else:
                logger.warning(f"_id formatı beklenmedik: {id_field}, Tür: {type(id_field)}")
                continue

            if not scraped_data_id:
                logger.warning(f"_id eksik veya hatalı: {id_field}")
                continue

            formatted_item = {
                "text": item.get("text"),
                "image": item.get("image_url"),
                "scrapedDataId": scraped_data_id
            }
            formatted_data.append(formatted_item)

        logger.info(f"{len(formatted_data)} tweet API'den çekildi.")
        return formatted_data

    except requests.RequestException as e:
        logger.error(f"Scraped data çekme hatası: {e}, Ham cevap: {e.response.text if e.response else 'Yok'}")
        return []
    except Exception as e:
        logger.error(f"Beklenmedik hata: {e}")
        return []

def post_filtered_data(filtered_data):
    """
    İşlenmiş veriyi POST /filtered-datas endpoint'ine gönderir.
    """
    try:
        headers = {
            "Authorization": AUTH_TOKEN,
            "Content-Type": "application/json"
        }
        # POST verisini kontrol et ve None değerleri temizle
        payload = {
            "summary_note": filtered_data.get("summary_note", "") or "",
            "address_link": filtered_data.get("address_link", "") or "",
            "address": filtered_data.get("address", {}) or {},
            "coordinates": filtered_data.get("coordinates", []) or []
        }
        logger.debug(f"POST payload: {json.dumps(payload, ensure_ascii=False)}")
        response = requests.post(FILTERED_DATA_API, headers=headers, json=payload, timeout=10)
        response.raise_for_status()
        logger.info(f"Veri başarıyla POST edildi: {response.status_code}")
        return True

    except requests.RequestException as e:
        logger.error(f"Filtered data POST hatası: {e}, Yanıt: {e.response.text if e.response else 'Yok'}")
        return False

def mark_data_as_used(scraped_data_id):
    """
    İşlenen veriyi mark-used endpoint'ine bildirir.
    """
    try:
        headers = {
            "Authorization": AUTH_TOKEN,
            "Content-Type": "application/json"
        }
        payload = {
            "scrapedDataId": scraped_data_id
        }
        response = requests.post(MARK_USED_API, headers=headers, json=payload, timeout=10)
        response.raise_for_status()
        logger.info(f"Veri başarıyla mark edildi (ID: {scraped_data_id}): {response.status_code}")
        return True

    except requests.RequestException as e:
        logger.error(f"Mark used hatası (ID: {scraped_data_id}): {e}")
        return False

def process_data():
    """
    Ham verileri çeker, işler ve filtered-datas endpoint'ine POST eder.
    """
    try:
        # Ham verileri çek
        scraped_tweets = fetch_scraped_data()
        if not scraped_tweets:
            logger.warning("Çekilecek veri bulunamadı.")
            return 0

        processed_count = 0
        batch_size = 5  # Her 5 tweet'te bir 1 dakika bekleme
        for i, tweet in enumerate(scraped_tweets):
            tweet_text = tweet.get("text")
            tweet_image = tweet.get("image")
            scraped_data_id = tweet.get("scrapedDataId")

            if not tweet_text or not scraped_data_id:
                logger.warning(f"Tweet eksik veri içeriyor (ID: {scraped_data_id}): text={tweet_text}")
                continue

            logger.info(f"Tweet İşleniyor (ID: {scraped_data_id}): {tweet_text}")
            if tweet_image:
                logger.info(f"Görsel içeren tweet işleniyor (ID: {scraped_data_id})")
                image_text = image_to_text(tweet_image)
                tweet_text += f"\n\nGörselden okunan metin: {image_text}"

            try:
                result = analyze_social_post(tweet_text)
                logger.info("Analiz Sonucu:")
                logger.info(json.dumps(result, indent=2, ensure_ascii=False))

                # Eğer veri geçerliyse POST et ve mark et
                if result.get("is_valid", False):
                    if post_filtered_data(result):
                        mark_data_as_used(scraped_data_id)
                        processed_count += 1

            except Exception as e:
                logger.error(f"Tweet işleme hatası (ID: {scraped_data_id}): {e}")
                continue

            # Her 5 tweet'te 1 dakika bekle
            if (i + 1) % batch_size == 0:
                logger.info(f"Batch tamamlandı, 60 saniye bekleniyor... ({i + 1}/{len(scraped_tweets)} tweet işlendi)")
                time.sleep(60)

        logger.info(f"Toplam {processed_count} tweet işlendi ve POST/mark edildi.")
        return processed_count

    except Exception as e:
        logger.error(f"Genel Hata: {e}")
        return 0

def process_all_data():
    """
    Tüm database'i işler (bir seferlik işlem).
    """
    try:
        # Tüm verileri çek
        scraped_tweets = fetch_scraped_data()
        if not scraped_tweets:
            logger.warning("Çekilecek veri bulunamadı.")
            return 0

        processed_count = 0
        batch_size = 5  # Her 5 tweet'te bir 1 dakika bekleme
        for i, tweet in enumerate(scraped_tweets):
            tweet_text = tweet.get("text")
            tweet_image = tweet.get("image")
            scraped_data_id = tweet.get("scrapedDataId")

            if not tweet_text or not scraped_data_id:
                logger.warning(f"Tweet eksik veri içeriyor (ID: {scraped_data_id}): text={tweet_text}")
                continue

            logger.info(f"Tweet İşleniyor (ID: {scraped_data_id}): {tweet_text}")
            if tweet_image:
                logger.info(f"Görsel içeren tweet işleniyor (ID: {scraped_data_id})")
                image_text = image_to_text(tweet_image)
                tweet_text += f"\n\nGörselden okunan metin: {image_text}"

            try:
                result = analyze_social_post(tweet_text)
                logger.info("Analiz Sonucu:")
                logger.info(json.dumps(result, indent=2, ensure_ascii=False))

                # Eğer veri geçerliyse POST et
                if result.get("is_valid", False):
                    if post_filtered_data(result):
                        processed_count += 1

                # Her tweet işlendikten sonra used olarak işaretle (ilk sefer için)
                mark_data_as_used(scraped_data_id)

            except Exception as e:
                logger.error(f"Tweet işleme hatası (ID: {scraped_data_id}): {e}")
                # Hata olsa bile used olarak işaretle
                mark_data_as_used(scraped_data_id)
                continue

            # Her 5 tweet'te 1 dakika bekle
            if (i + 1) % batch_size == 0:
                logger.info(f"Batch tamamlandı, 60 saniye bekleniyor... ({i + 1}/{len(scraped_tweets)} tweet işlendi)")
                time.sleep(60)

        logger.info(f"Toplam {processed_count} tweet işlendi ve POST/mark edildi.")
        return processed_count

    except Exception as e:
        logger.error(f"Genel Hata: {e}")
        return 0

def run_periodically(interval_minutes=1):
    """
    Verileri periyodik olarak çeker ve işler.
    interval_minutes: İşleme aralığı (dakika cinsinden)
    """
    schedule.every(interval_minutes).minutes.do(process_data)

    logger.info(f"Veri işleme her {interval_minutes} dakikada bir çalışacak...")
    while True:
        try:
            schedule.run_pending()
            time.sleep(60)  # Her dakika kontrol et
        except KeyboardInterrupt:
            logger.info("Periyodik işlem durduruldu.")
            break
        except Exception as e:
            logger.error(f"Periyodik işlem hatası: {e}")
            time.sleep(60)  # Hata olsa bile devam et

# --- Terminal Testi ---
if __name__ == "__main__":
    logger.info("Tüm database işleniyor...")
    process_all_data()

    run_periodically(interval_minutes=1)