OriginDex/Site/OriginDex.py

import sqlite3
from flask import Flask, render_template, jsonify
from collections import defaultdict
import os

app = Flask(__name__)

def load_pokemon_data():
    pokemon_list = []
    
    conn = sqlite3.connect('pokemon_forms.db')
    cursor = conn.cursor()

    # First query: Get all Pokémon data
    cursor.execute('''
        SELECT 
            pf.national_dex, pf.name, pf.form_name, pf.PFIC, pf.generation,
            ps.storable_in_home
        FROM pokemon_forms pf
        JOIN pokemon_storage ps ON pf.PFIC = ps.PFIC
        WHERE ps.storable_in_home = 1
        ORDER BY pf.PFIC
    ''')
    
    pokemon_data = cursor.fetchall()

    # Function to get the origin mark for a Pokémon
    def get_origin_mark(pfic, generation):
        # Step 1: Check for previous evolution in the same generation
        cursor.execute('''
            WITH RECURSIVE EvolutionChain AS (
                SELECT ec.to_pfic, ec.from_pfic, pf_to.generation as to_gen, pf_from.generation as from_gen
                FROM evolution_chains ec
                JOIN pokemon_forms pf_to ON ec.to_pfic = pf_to.PFIC
                JOIN pokemon_forms pf_from ON ec.from_pfic = pf_from.PFIC
                WHERE ec.to_pfic = ? AND pf_to.generation = ?
                UNION ALL
                SELECT ec.to_pfic, ec.from_pfic, pf_to.generation, pf_from.generation
                FROM evolution_chains ec
                JOIN EvolutionChain e ON ec.to_pfic = e.from_pfic
                JOIN pokemon_forms pf_to ON ec.to_pfic = pf_to.PFIC
                JOIN pokemon_forms pf_from ON ec.from_pfic = pf_from.PFIC
                WHERE pf_to.generation = ? AND pf_from.generation = ?
            )
            SELECT from_pfic
            FROM EvolutionChain
            WHERE from_pfic IS NOT NULL AND from_gen = ?
            ORDER BY from_pfic
            LIMIT 1
        ''', (pfic, generation, generation, generation, generation))
        base_pfic = cursor.fetchone()
        
        if base_pfic:
            pfic = base_pfic[0]
        
        # Step 2: Look for the earliest encounter for this form in the current generation
        cursor.execute('''
            SELECT g.name, m.icon_path, m.id
            FROM encounters e
            JOIN games g ON e.game_id = g.id
            LEFT JOIN mark_game_associations mga ON g.id = mga.game_id
            LEFT JOIN marks m ON mga.mark_id = m.id
            WHERE e.pfic = ? AND g.generation = ?
            ORDER BY g.id
            LIMIT 1
        ''', (pfic, generation))
        encounter_data = cursor.fetchone()
        
        if encounter_data:
            return encounter_data
        
        # Step 3: Look for encounters of previous evolutions in the current generation
        cursor.execute('''
            WITH RECURSIVE EvolutionChain AS (
                SELECT ec.to_pfic, ec.from_pfic
                FROM evolution_chains ec
                WHERE ec.to_pfic = ?
                UNION ALL
                SELECT ec.to_pfic, ec.from_pfic
                FROM evolution_chains ec
                JOIN EvolutionChain e ON ec.to_pfic = e.from_pfic
            )
            SELECT g.name, m.icon_path, m.id
            FROM EvolutionChain ec
            JOIN encounters e ON ec.from_pfic = e.pfic
            JOIN games g ON e.game_id = g.id
            LEFT JOIN mark_game_associations mga ON g.id = mga.game_id
            LEFT JOIN marks m ON mga.mark_id = m.id
            WHERE g.generation = ?
            ORDER BY g.id
            LIMIT 1
        ''', (pfic, generation))
        evolution_encounter_data = cursor.fetchone()
        
        if evolution_encounter_data:
            return evolution_encounter_data
        
        # Step 4: Use the mark of the earliest game of the generation
        cursor.execute('''
            SELECT g.name, m.icon_path, m.id
            FROM games g
            LEFT JOIN mark_game_associations mga ON g.id = mga.game_id
            LEFT JOIN marks m ON mga.mark_id = m.id
            WHERE g.generation = ?
            ORDER BY g.id
            LIMIT 1
        ''', (generation,))
        generation_data = cursor.fetchone()
        
        return generation_data if generation_data else (None, None, None)

    # Process the data
    current_group = []
    current_generation = None
    current_dex_number = None
    pokemon_forms = []
    
    for row in pokemon_data:
        national_dex, name, form_name, pfic, generation, storable_in_home = row
        
        earliest_game, mark_icon, mark_id = get_origin_mark(pfic, generation)

        pokemon = {
            'pfic': pfic,
            'ID': national_dex,
            'Name': name,
            'Form': form_name if form_name else "Default",
            'Image': f"images/pokemon/{pfic}.png",
            'IsDefault': form_name is None or form_name == '',
            'Generation': generation,
            'EarliestGame': earliest_game,
            'StorableInHome': storable_in_home,
            'MarkIcon': mark_icon,
            'MarkID': mark_id
        }
        
        # Add the Pokémon to the current group
        if national_dex != current_dex_number:
            if pokemon_forms:
                for form in pokemon_forms:
                    current_group.append(form)
                    if len(current_group) == 30:
                        pokemon_list.append(current_group)
                        current_group = []
            pokemon_forms = []
            current_dex_number = national_dex
            
            if form_name is None or form_name == '':
                if current_generation is None or generation != current_generation:
                    if current_group:
                        while len(current_group) < 30:
                            current_group.append(None)  # Add empty slots
                        pokemon_list.append(current_group)
                    current_group = []
                    current_generation = generation
        
        pokemon_forms.append(pokemon)
    
    # Add the last set of forms
    for form in pokemon_forms:
        current_group.append(form)
        if len(current_group) == 30:
            pokemon_list.append(current_group)
            current_group = []
    
    # Add any remaining Pokémon
    if current_group:
        while len(current_group) < 30:
            current_group.append(None)  # Add empty slots to the last group
        pokemon_list.append(current_group)

    conn.close()
    return pokemon_list

@app.route('/')
def index():
    pokemon_list = load_pokemon_data()
    return render_template('index.html', grouped_pokemon=pokemon_list)

@app.route('/pokemon/<string:pfic>')
def pokemon_details(pfic):
    conn = sqlite3.connect('pokemon_forms.db')
    cursor = conn.cursor()

    cursor.execute('''
        SELECT pf.form_name, g.name, g.id as game_id, e.location, e.day, e.time, 
               e.dual_slot, e.static_encounter, e.static_encounter_count, 
               e.extra_text, e.stars, e.fishing, e.rods, e.starter
        FROM pokemon_forms pf
        JOIN encounters e ON pf.PFIC = e.pfic
        JOIN games g ON e.game_id = g.id
        WHERE pf.pfic = ?
        ORDER BY g.id, pf.form_name, e.location
    ''', (pfic,))

    encounters = [
        {
            'form': form,
            'game': game,
            'game_id': game_id,
            'location': location,
            'day': day,
            'time': time,
            'dual_slot': dual_slot,
            'static_encounter': static_encounter,
            'static_encounter_count': static_encounter_count,
            'extra_text': extra_text,
            'stars': stars,
            'fishing': fishing,
            'rods': rods,
            'starter': starter
        }
        for form, game, game_id, location, day, time, dual_slot, static_encounter, static_encounter_count, 
            extra_text, stars, fishing, rods, starter in cursor.fetchall()
    ]

    conn.close()
    return jsonify(encounters)

if __name__ == '__main__':
    extra_files = ['.']
    extra_dirs = ['./templates/', './static/']
    for extra_dir in extra_dirs:
        for dirname, dirs, files in os.walk(extra_dir):
            for filename in files:
                filename = os.path.join(dirname, filename)
                if os.path.isfile(filename):
                    extra_files.append(filename)

    app.run(debug=True, extra_files=extra_files)