from flask import Flask, request
  from notion_client import Client
  import os

  from helper_functions import fetch_data_from_omdb, map_omdb_to_notion_schema, add_entry_to_notion

  # --- Config ---
  OMDB_API_KEY = "" # Your OMDB API key here
  TELEGRAM_TOKEN = "" # Your Telegram bot token here
  NOTION_TOKEN = "" # Your Notion integration token here
  DATABASE_ID = "" # Your Notion database ID here

  # Notion client
  notion = Client(auth=NOTION_TOKEN)

  # Flask app
  app = Flask(__name__)

  # Temporary storage for pending confirmations (user_id → movie data)
  pending_movies = {}

  # --- Telegram webhook endpoint ---
  @app.route(f"/{TELEGRAM_TOKEN}", methods=["POST"])
  def telegram_webhook():
      update = request.get_json()

      # --- 1. Handle CallbackQuery (button clicks) ---
      if "callback_query" in update:
          callback = update["callback_query"]
          user_id = callback["from"]["id"]
          data = callback["data"]
          chat_id = callback["message"]["chat"]["id"]

          if data == "confirm":
              movie = pending_movies.pop(user_id, None)
              if movie:
                  add_entry_to_notion(notion, DATABASE_ID, movie)
                  edit_message(chat_id, callback["message"]["message_id"], f"Added *{movie['Title']}* to Notion! 🎉")
              else:
                  edit_message(chat_id, callback["message"]["message_id"], "No pending movie to confirm.")
          elif data == "cancel":
              pending_movies.pop(user_id, None)
              edit_message(chat_id, callback["message"]["message_id"], "Cancelled.")
          return "ok"

      # --- 2. Handle New Message (movie title) ---
      message = update.get("message", {})
      chat_id = message.get("chat", {}).get("id")
      user_id = message.get("from", {}).get("id")
      title = message.get("text")

      if not title:
          send_message(chat_id, "Please send me a movie or tv show title.")
          return "ok"

      try:
          # Fetch OMDB
          omdb_data = fetch_data_from_omdb(title, OMDB_API_KEY)
          if not omdb_data:
              send_message(chat_id, "Movie or TV Show not found. Please check the title and try again.")
              return "ok"

          # Map to Notion schema
          mapped = map_omdb_to_notion_schema(omdb_data)

          # Save temporarily for confirmation
          pending_movies[user_id] = mapped

          # Build details message
          text = (
              f"*{mapped['Title']}* ({mapped['Released']})\n"
              f"Rated: {mapped['Rated']}\n"
              f"Runtime: {mapped['Runtime']}\n"
              f"Genre: {mapped['Genre']}\n"
              f"Director: {mapped['Director']}\n"
              f"Actors: {mapped['Actors']}\n\n"
              f"{mapped['Plot']}\n\n"
              f"IMDb: {mapped['imdbRating']} | Metascore: {mapped['Metascore']}"
          )

          # Inline keyboard buttons
          keyboard = {
              "inline_keyboard": [
                  [
                      {"text": "✅ Add to Notion", "callback_data": "confirm"},
                      {"text": "❌ Cancel", "callback_data": "cancel"},
                  ]
              ]
          }

          send_message(chat_id, text, reply_markup=keyboard)

      except Exception as e:
          send_message(chat_id, f"Error: {e}")

      return "ok"

  @app.route("/")
  def home():
      return "Bot is running."


  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=5000)

  import requests

  def edit_message(chat_id, message_id, text):
      url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/editMessageText"
      payload = {
          "chat_id": chat_id,
          "message_id": message_id,
          "text": text,
          "parse_mode": "Markdown"
      }
    requests.post(url, json=payload)

  import requests

  def send_message(chat_id, text, reply_markup=None):
      url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
      payload = {
          "chat_id": chat_id,
          "text": text,
          "parse_mode": "Markdown"
      }
      if reply_markup:
          payload["reply_markup"] = reply_markup
      requests.post(url, json=payload)

  import requests

  def fetch_data_from_omdb(title: str, OMDB_API_KEY: str) -> dict:
      """
      Fetch movie or show data from OMDB API using the provided title.
      If the title is not found, return None.
      """
      
      url = f"http://www.omdbapi.com/?t={title}&apikey={OMDB_API_KEY}"
      response = requests.get(url)
      data = response.json()
      if data.get("Response") == "False":
          raise Exception(f"Movie not found: {data.get('Error')}")
      return data

  from notion_client import Client

  def add_entry_to_notion(notion_client: Client, database_id: str, data: dict):
      """
      Adds a movie entry to a Notion database.
      
      :param notion_client: Initialized Notion Client
      :param database_id: The Notion database ID
      :param data: Dictionary with movie details
      """
      
      # Helper: safely get value
      def get_value(key, default=""):
          return data.get(key, default) or default

      # Convert string to float if numeric
      def parse_float(val):
          try:
              return float(val)
          except (ValueError, TypeError):
              return None

      properties = {
          "Title": {
              "title": [{"text": {"content": get_value("Title")}}]
          },
          "Favorite": {
              "checkbox": bool(get_value("Favorite"))
          },
          "Status": {
              "status": {"name": get_value("Status")}
          },
          "Type": {
              "select": {"name": get_value("Type")}
          },
          "Rated": {
              "rich_text": [{"text": {"content": get_value("Rated")}}]
          },
          "Release Date": {
              "rich_text": [{"text": {"content": get_value("Released")}}]
          },
          "Runtime": {
              "rich_text": [{"text": {"content": get_value("Runtime")}}]
          },
          "Genre": {
              "rich_text": [{"text": {"content": get_value("Genre")}}]
          },
          "Director": {
              "rich_text": [{"text": {"content": get_value("Director")}}]
          },
          "Actors": {
              "rich_text": [{"text": {"content": get_value("Actors")}}]
          },
          "Plot": {
              "rich_text": [{"text": {"content": get_value("Plot")}}]
          },
          "Metascore": {
              "number": parse_float(get_value("Metascore"))
          },
          "imdbRating": {
              "number": parse_float(get_value("imdbRating"))
          },
          "Where to watch": {
              "rich_text": [{"text": {"content": get_value("Where to watch")}}]
          },
          "URL": {
              "url": get_value("URL")
          }
      }

      # Create page
      response = notion_client.pages.create(
          parent={"database_id": database_id},
          properties=properties
      )

      return response

  def map_omdb_to_notion_schema(omdb_data: dict):
      return {
          "Status": "To watch",
          "Title": omdb_data.get("Title", ""),
          "Type": omdb_data.get("Type", ""),
          "Rated": omdb_data.get("Rated", ""),
          "Released": omdb_data.get("Released", ""),
          "Runtime": omdb_data.get("Runtime", ""),
          "Genre": omdb_data.get("Genre", ""),
          "Director": omdb_data.get("Director", ""),
          "Actors": omdb_data.get("Actors", ""),
          "Plot": omdb_data.get("Plot", ""),
          "Metascore": omdb_data.get("Metascore", ""),
          "imdbRating": omdb_data.get("imdbRating", ""),
          "Where to watch": "",
          "Favorite": False,
          "URL": f"https://www.imdb.com/title/{omdb_data.get('imdbID')}/" if omdb_data.get("imdbID") else ""
      }