from flask import Flask, render_template, request, jsonify, redirect, url_for
import time
from services.torrents import initiate_config, serialize_operation_result

from models.request_data import RequestData
from flask_caching import Cache
from flask_sqlalchemy import SQLAlchemy


from toloka2MediaServer.main_logic import (
    add_release_by_url, update_release_by_name, update_releases,
    search_torrents, get_torrent as get_torrent_external,
    add_torrent as add_torrent_external
)

cache = Cache(config={'CACHE_TYPE': 'SimpleCache'})
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///t2w.db"
cache.init_app(app)

from sqlalchemy.orm import DeclarativeBase, MappedAsDataclass

class Base(DeclarativeBase, MappedAsDataclass):
  pass

db = SQLAlchemy(app, model_class=Base)

from models.db import ImagesCache

with app.app_context():
    db.create_all()

@app.route("/")
@cache.cached(timeout=1)
def root_route():
    sections = []
    config = initiate_config()
    titles = config.titles_config
    new_torrent = 0
    for title in titles.sections():
        if request.args.get('query', '') in title:
            image_cache = db.session.execute(db.select(ImagesCache).filter_by(codename=title)).scalar_one_or_none()
            if image_cache:
                titles[title]["image"] = image_cache.image
            else:
                toloka_torrent = config.toloka.get_torrent(f"https://toloka.to/{titles[title]["guid"]}")
                toloka_img = f"https:{toloka_torrent.img}" if toloka_torrent.img.startswith("//") else toloka_torrent.img
                db.session.add(ImagesCache(title, toloka_img))
                db.session.commit()

                titles[title]["image"] = toloka_img

            # Config data
            titles[title]["codename"] = title
            titles[title]["torrent_name"] = titles[title]["torrent_name"].replace("\"", "")
            sections.append(titles[title])

    return render_template('index.html', titles = sections, new_torrent = new_torrent)

# First stage
@app.route("/add")
def add_route():
    config = initiate_config()
    if request.args.get('query'):
        torrent = config.toloka.get_torrent(request.args.get('query'))
        return render_template('add.html', torrent = torrent, episode_integers = [i for i in ''.join((ch if ch.isdigit() else ' ') for ch in f"{torrent.files[0].folder_name}/{torrent.files[0].file_name}").split()], default_dir = config.app_config.get("Toloka", "default_download_dir"))
    
    if len(request.args) == 6:
        requestData = RequestData(
            url = request.args["toloka_url"],
            season = request.args["season-index"],
            index = int(request.args["episode-index"]),
            correction = int(request.args['adjusted-episode-number']),
            title = request.args["dirname"],
        )

        config.args = requestData
        operation_result = add_release_by_url(config)
        output = serialize_operation_result(operation_result)
        return redirect(url_for('root_route'))

    return render_template('add.html')

@app.route("/about")
def about_route():
    return render_template('about.html')

@app.route("/settings")
def settings_route():
    return render_template('settings.html')

@app.route("/delete/<codename>")
def delete_route(codename):
    config = initiate_config()
    titles = config.titles_config
    titles.remove_section(codename)
    with open("data/titles.ini", "w") as f:
        titles.write(f)

    return f"{codename} успішно видалений."

@app.route("/update/", defaults={'codename': None})
@app.route("/update/<codename>")
def update_route(codename):
    # Process the name to update release
    try:
        config = initiate_config()
        requestData = RequestData(
            codename = codename
        )
        if codename:
            config.args = requestData
            operation_result = update_release_by_name(config)
        else:
            config.args = RequestData()
            operation_result = update_releases(config)

        output = serialize_operation_result(operation_result)
        return output
    except Exception as e:
        message = f'Error: {str(e)}'
        return {"error": message}