import sqlite3, random, re

def connect() -> sqlite3.Connection:
    db = sqlite3.connect("cache.sqlite")
    
    db.execute('PRAGMA temp_store = OFF')
    db.execute('PRAGMA journal_mode = MEMORY')
    db.execute('PRAGMA synchronous = OFF')
    db.commit()
    return db

class Element:
    def __init__(
        self,
        name: str,
        emoji: str | None = None,
        database_id: int | None = None,
    ) -> None:
        self.name = name
        self.emoji = emoji or "\N{BLACK QUESTION MARK ORNAMENT}"
        self.database_id = database_id

    def __hash__(self) -> int:
        return hash(self.name)

    def __eq__(self, other: "Element") -> bool:
        return self.name == other.name

    def __str__(self) -> str:
        return f"{self.emoji} {self.name}"

    def __repr__(self) -> str:
        return repr(str(self))

    @property
    def numeric(self) -> bool:
        return re.search(r"\d", self.name) is not None

class Pair:
    def __init__(
        self,
        first: Element,
        second: Element,
        result: Element,
        is_discovery: bool | None = None,
    ) -> None:
        self.first = first
        self.second = second
        self.result = result
        self.is_discovery = is_discovery is True

    def __str__(self) -> str:
        addendum = " (New Discovery!)" if self.is_discovery else ""
        return f"{self.first} + {self.second} = {self.result}{addendum}"

    def __repr__(self) -> str:
        addendum = " (New Discovery!)" if self.is_discovery else ""
        return f"{self.first!r} + {self.second!r} = {self.result!r}{addendum}"

    @property
    def elements(self) -> tuple[Element, Element, Element]:
        return self.first, self.second, self.result

def _upsert_element(conn: sqlite3.Connection, element: Element) -> None:
    conn.execute(
        """
        INSERT INTO element (name, emoji)
        VALUES (?, ?)
        ON CONFLICT(name) DO UPDATE SET
        emoji = excluded.emoji
        """,
        (element.name, element.emoji),
    )

    (element.database_id,) = conn.execute(
        "SELECT id FROM element WHERE name = ?",
        (element.name,),
    ).fetchone()


def _upsert_pair(conn: sqlite3.Connection, pair: Pair) -> None:
    # first, insert the elements:
    for element in pair.elements:
        if element.database_id is not None:
            continue

        _upsert_element(conn, element)

    # now, record the pair:
    conn.execute(
        """
        INSERT INTO pair (first_element_id, second_element_id, result_element_id, is_discovery)
        VALUES (?, ?, ?, ?)
        ON CONFLICT(first_element_id, second_element_id) DO UPDATE SET
        result_element_id = excluded.result_element_id,
        is_discovery = MAX(is_discovery, excluded.is_discovery)
        """,
        (*(e.database_id for e in pair.elements), 1 if pair.is_discovery else 0),
    )


def record_pair(pair: Pair) -> None:
    with connect() as conn:
        _upsert_pair(conn, pair)

def get_name_and_emoji(db, id):
    try:
        (name, emoji) = db.execute('SELECT name, emoji FROM element WHERE id = ?', (id,)).fetchone()
        return name, emoji
    except:
        return None, None

old_db = sqlite3.connect("fully_merged_database.sqlite")

new_db = sqlite3.connect('cache.sqlite')
new_db.execute(
    """
    CREATE TABLE IF NOT EXISTS element (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        first_created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
        name TEXT UNIQUE,
        emoji TEXT
    )
    """,
)

new_db.execute(
    """
    CREATE TABLE IF NOT EXISTS pair (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
        first_element_id INTEGER,
        second_element_id INTEGER,
        result_element_id INTEGER,
        is_discovery INTEGER,
        FOREIGN KEY (first_element_id) REFERENCES element (id),
        FOREIGN KEY (second_element_id) REFERENCES element (id),
        FOREIGN KEY (result_element_id) REFERENCES element (id)
        UNIQUE(first_element_id, second_element_id)
    )
    """,
)

with connect() as conn:
    primary_elements = [
        Element("Fire", "\N{FIRE}"),
        Element("Earth", "\N{EARTH GLOBE EUROPE-AFRICA}"),
        Element("Water", "\N{DROPLET}"),
        Element("Wind", "\N{WIND BLOWING FACE}"),
    ]

    # The search order is "mostly deterministic" on the macroscopic scale
    # so randomize the order of the primary elements so that everyone who runs
    # this code gets one of 4! (factorial) possible "macroscopic routes"
    random.shuffle(primary_elements)

    for e in primary_elements:
        _upsert_element(conn, e)

new_db.commit()

old_db.execute('PRAGMA temp_store = OFF')
old_db.execute('PRAGMA journal_mode = MEMORY')
old_db.execute('PRAGMA synchronous = OFF')
old_db.commit()

new_db.close()

count = 0
for item in old_db.execute('SELECT id, first_element_id, second_element_id, result_element_id, is_discovery FROM pair'):
    id, first, second, result, is_discovery = item
    name, emoji = get_name_and_emoji(old_db, first)
    first = Element(name, emoji)
    if not first:
        old_db.execute('DELETE FROM pair WHERE id = ?', (id,))
        old_db.commit()
        total -= 1 
        continue   
    name, emoji = get_name_and_emoji(old_db, second)
    second = Element(name, emoji)
    if not second:
        old_db.execute('DELETE FROM pair WHERE id = ?', (id,))
        old_db.commit()
        total -= 1
        continue
    name, emoji = get_name_and_emoji(old_db, result)
    result = Element(name, emoji)
    if not result:
        old_db.execute('DELETE FROM pair WHERE id = ?', (id,))
        old_db.commit()
        total -= 1
        continue
    is_discovery = True if is_discovery == 1 else False
    pair = Pair(first, second, result, is_discovery)
    record_pair(pair)
    count += 1
    print(f'(#{count:,}) Done: {first} + {second} = {result}                                   ', end='\r')