#!/usr/bin/env python
"""
Dump public toots
"""

# import sqlite3

# con = sqlite3.connect("registered_app.db")

# cur = con.cursor()
# cur.execute("CREATE TABLE registered_app(title, year, score)")


import argparse
import collections
from sqlalchemy import Column, Integer, String, create_engine, UniqueConstraint, select
from sqlalchemy.orm import declarative_base, Session
from mastodon import Mastodon
import socket
import requests.packages.urllib3.util.connection as urllib3_cn
import requests


Base = declarative_base()

# Disable ipv6


def allowed_gai_family():
    """
     https://github.com/shazow/urllib3/blob/master/urllib3/util/connection.py
    """
    return socket.AF_INET

urllib3_cn.allowed_gai_family = allowed_gai_family

class RegisteredApp(Base):
    """RegisteredApp"""

    __tablename__ = "registered_app"
    __table_args__ = (UniqueConstraint("url", "name", name="_url_name_uc"),)

    id = Column(Integer, primary_key=True)
    url = Column(String)
    name = Column(String)
    key = Column(String, unique=True, index=True)
    secret = Column(String)

    def __repr__(self):
        return f"RegisteredApp(id={self.id!r}, url={self.url!r}, name={self.name!r})"


AppKeySecret = collections.namedtuple(
    "AppKeySecret", ("key", "secret", "url"), defaults=(None, None, None)
)

def get_application_secret(name, url, db_con):
    """Get the application id and secret

    Args:
        name (String): The name of the application
        url (String): The mastodon base url (without http(s))
        db_con (Connection): The database connection

    Returns:
        AppKeySecret: The application secret
    """
    # get existing secret keys
    stmt = select(RegisteredApp).where(
        RegisteredApp.url == url, RegisteredApp.name == name
    )
    result = db_con.execute(stmt).fetchone()

    if result:
        return AppKeySecret(key=result.key, secret=result.secret, url=url)

    (client_id, client_secret) = Mastodon.create_app(
        name,
        api_base_url = f'https://{url}'
    )

    registered_app = RegisteredApp(name=name, url=url, key=client_id, secret=client_secret)
    with Session(db_con) as session:
        session.add(registered_app)
        session.commit()

    return AppKeySecret(key=client_id, secret=client_secret, url=url)

def get_public_statuses(appKeySecret, tag, limit=40):
    mastodon = Mastodon(client_id=appKeySecret.key, client_secret=appKeySecret.secret, api_base_url=f'https://{appKeySecret.url}')
    results = mastodon.timeline_hashtag(hashtag=tag, limit=limit)
    while results:
        for status in results:
            print("-------------------------")
            print(repr(status))
        results = mastodon.fetch_next(results)


def parse_arg():
    """
    parse args
    """
    parser = argparse.ArgumentParser(
        prog="dump_public_toots",
        description="Dump the latest public toots",
        epilog="dump only public toots",
    )
    parser.add_argument(
        "-d",
        "--database",
        dest="database",
        default="registered_apps.sqlite",
        help="The path to the registered apps db",
    )
    parser.add_argument(
        "-u", "--url", dest="url", help="The mastodon base url", required=True
    )
    parser.add_argument(
        "-n", "--name", dest="name", help="The application name", required=True
    )
    parser.add_argument(
        "-t", "--tag", dest="tag", help="The tag to search", required=True
    )
    parser.add_argument(
        "-l", "--limit", dest="limit", help="page size", required=False, default=40
    )


    return parser.parse_args()


if __name__ == "__main__":

    options = parse_arg()

    # req = requests.get(f"https://{options.url}/api/v1/timelines/tag/{options.tag}/")
    # print(req.text)


    app_db_eng = create_engine(f"sqlite+pysqlite:///{options.database}", future=True)

    with app_db_eng.connect() as app_db_con:
        Base.metadata.create_all(app_db_con)

        keySecret = get_application_secret(options.name, options.url, app_db_con)

        get_public_statuses(keySecret, options.tag, options.limit)

        app_db_con.commit()