// Search items
router.get("/todos/search/:search", 
    authorization, 
    async(req, res) => {
        try {
            const { search } = req.params;
            const user_data = await db.query(
                "SELECT u.user_name, t.todo_id, t.description 
                FROM users as u 
                LEFT JOIN todos as t 
                ON u.user_id = t.user_id 
                WHERE (u.user_id=$1 
                AND (description LIKE ('%' || $2 || '%'))) 
                ORDER BY t.todo_id asc",
                [req.user.id, search]
            );
            res.json(user_data.rows);
        } catch (error) {
            console.error(error.message);
        }
})
                                                    
                                                

                                                    
// Dashboard Route //
const router = require("express").Router();
const authorization = require("../middleware/auth");
const db = require("../db");

// Get All Items
router.get("/", authorization, 
    async (req, res) => {...
});
// Create a Item
router.post("/todos", authorization, 
    async (req, res) => {...
});
// Update a Item
router.put("/todos/:todo_id", authorization, 
    async (req, res) => {...
});
// Delete a Item
router.delete("/todos/:todo_id", authorization, 
    async (req, res) => {...
});
// Search Items
router.get("/todos/search/:search", authorization, 
    async (req, res) => {...
});
                                                    
                                                

                                                    
import jwt, {Secret} from "jsonwebtoken";
import {Request, Response} from "express";
import dotenv from 'dotenv';
dotenv.config()

export default async (req: Request, res: Response, next: any) => {
    try {
        // grab token from request header
        const jwtToken = req.header("token");
        // check if there is no token given
        if (!jwtToken) {
            return res.status(403).json("Not Authorized");
        }
        // use jwt to verify the token with the secret key
        const secret_key: Secret = process.env.jwtSecret!;
        const payload = jwt.verify(jwtToken, secret_key) as {user: {id: string}};
        req.user = payload.user;
        next();
    } catch (error: any) {
        console.error(error.message);
        return res.status(403).json("Authoization: Not Authorized")
    }
}
                                                    
                                                

                                                    
def monte_carlo(board, team, depth, trials):
    """
    given a board state, team, move depth, and number of trials, 
    # runs the full monte carlo simulation for that state, 
    # and return a tuple representation of the optimal move 
    """
    move_list = board.get_all_moves(team)
    score_tracker = {move: [] for move in move_list}

    # apply all possible current moves for the current team, 
    # then call run_sim for the resulting board state of each of those moves. 
    # Builds a dictionary with keys of each possible move, 
    # and values of the average game score
    for move in score_tracker:
        clone_board = board.clone()
        clone_board.apply_move(move[0], move[1])
        score_tracker[move] = run_sim(clone_board, team, depth, trials)

    # return the move with either the minimum or maximum gamescore 
    # depending on if the current team is BLACK (min) or WHITE (max)
    if team == chessgame.BLACK:
        return min(score_tracker, key = lambda k: score_tracker[k])
    else:
        return max(score_tracker, key = lambda k: score_tracker[k])
                                                    
                                                

                                                    
async function getResponseFromChatGPT(pokeNames, randMoves) {
    try {
        const apiKey = process.env.chatApiKey;
        const url = `https://api.openai.com/v1/chat/completions`;
        const body = JSON.stringify({
            "model": "gpt-3.5-turbo", 
            "messages": [{
                "role": "user",
                "content": `Narrate a short pokemon battle between...`
            }],
            "temperature": 0, 
        });
        const myHeaders = new Headers();
        myHeaders.append("Content-Type", "application/json");
        myHeaders.append("Authorization", `Bearer ${apiKey}`);

        const response = await fetch(url, {
            body: body,
            method: 'POST',
            headers: myHeaders,
        });
    
        const data = await response.json();
        return data.choices[0].message.content.trim();
    }
                                                    
                                                

                                                    
function updatePokeHtml(pokeInfo) {
    let randNums = ["","","","","","","",""];
    document.getElementById('battle').innerText = 'Simulating...';
    pokeInfo.forEach((pokemon, pokeIdx) => {
        const nameDiv = document.getElementById(`poke-name-${pokeIdx}`);
        const spriteDiv = document.getElementById(`poke-sprite-${pokeIdx}`);
        const cardDiv = document.getElementById(`poke-card-${pokeIdx}`);
        let capName = pokemon.name.charAt(0).toUpperCase() + pokemon.name.slice(1);

        nameDiv.innerText = capName;
        spriteDiv.src = pokemon.sprites.front_default;
        cardDiv.style.backgroundColor = colors[pokemon.types[0].type.name];

        const typeElems = document.getElementById(`poke-type-${pokeIdx}`).children;
        for(i = 1; i < typeElems.length; i++) {
            typeElems[i].innerText = '';
        };

        pokemon.types.forEach((typeObj, typeIdx) => {
            const typeDiv = document.getElementById(`type${typeIdx}-${pokeIdx}`);
            typeDiv.innerText = typeObj.type.name;
            typeDiv.style.backgroundColor = colors[`${typeObj.type.name}2`];
        });
    });
    return randNums;
};