use super::primitive_functions::primitive_funcs;
use super::types::*;
use crate::ast;
use crate::ast::helpers;
use crate::interpret;
use gamepads;
use macroquad::prelude::*;

pub async fn setup(code: ast::Program) -> State {
    let font = load_ttf_font("./assets/fonts/monogram.ttf").await.unwrap();

    let mut state = match interpret::setup(code, primitive_funcs()) {
        Ok(state) => state,
        Err(err) => {
            println!("Error: {}", err);
            interpret::State::new("game".into(), primitive_funcs())
        }
    };
    let game_state = match interpret::interpret(&mut state, "setup".into(), vec![]) {
        Ok(result) => result,
        Err(err) => {
            println!("Error: {}", err);
            ast::UNIT_VALUE
        }
    };

    State {
        assets: Assets { font },
        state,
        game_state,
        gamepads: gamepads::Gamepads::new(),
    }
}

pub async fn migrate(mut state: State, code: ast::Program) -> State {
    println!("Migrating...");
    match interpret::setup(code, primitive_funcs()) {
        Err(err) => {
            println!("Error: {}", err);
            state
        }
        Ok(mut new_program_state) => {
            match interpret::value_to_stadnalone_expr(&state.state, state.game_state.clone()) {
                Err(err) => {
                    println!("Error: {}", err);
                    state
                }
                Ok(expanded_game_state) => {
                    match interpret::interpret(
                        &mut new_program_state,
                        "migrate".into(),
                        vec![expanded_game_state],
                    ) {
                        Err(err) => {
                            println!("Error: {}", err);
                            state
                        }
                        Ok(result) => {
                            println!("Success!");
                            state.game_state = result;
                            state.state = new_program_state;
                            state
                        }
                    }
                }
            }
        }
    }
}

pub fn update(state: &mut State, input: Input) {
    let input = helpers::record(vec![(
        "gamepad1",
        helpers::record(vec![
            (
                "buttons",
                helpers::record(vec![
                    ("a", input.gamepad1.buttons.a.into()),
                    ("b", input.gamepad1.buttons.b.into()),
                    ("x", input.gamepad1.buttons.x.into()),
                    ("y", input.gamepad1.buttons.y.into()),
                ]),
            ),
            (
                "dpad",
                helpers::record(vec![
                    ("left", input.gamepad1.dpad.left.into()),
                    ("right", input.gamepad1.dpad.right.into()),
                    ("up", input.gamepad1.dpad.up.into()),
                    ("down", input.gamepad1.dpad.down.into()),
                ]),
            ),
            (
                "sticks",
                helpers::record(vec![
                    (
                        "left",
                        helpers::record(vec![
                            ("x", input.gamepad1.left_stick.x.into()),
                            ("y", (0.0 - input.gamepad1.left_stick.y).into()),
                        ]),
                    ),
                    (
                        "right",
                        helpers::record(vec![
                            ("x", input.gamepad1.right_stick.x.into()),
                            ("y", (0.0 - input.gamepad1.right_stick.y).into()),
                        ]),
                    ),
                ]),
            ),
        ]),
    )]);
    match interpret::interpret(
        &mut state.state,
        "update".into(),
        vec![ast::Expr::Value(state.game_state.clone()), input],
    ) {
        Ok(_) => {}
        Err(err) => println!("Error: {}", err),
    }
}

pub fn fetch_events(state: &mut State) -> Input {
    state.gamepads.poll();
    let mut input = Input::new();

    for gamepad in state.gamepads.all() {
        //println!("{:#?}", gamepad.all_currently_pressed().collect::<Vec<_>>());
        // action buttons
        input.gamepad1.buttons.a = gamepad.is_currently_pressed(gamepads::Button::ActionRight);
        input.gamepad1.buttons.b = gamepad.is_currently_pressed(gamepads::Button::ActionDown);
        input.gamepad1.buttons.x = gamepad.is_currently_pressed(gamepads::Button::ActionUp);
        input.gamepad1.buttons.y = gamepad.is_currently_pressed(gamepads::Button::ActionLeft);

        // dpad
        input.gamepad1.dpad.left = gamepad.is_currently_pressed(gamepads::Button::DPadLeft);
        input.gamepad1.dpad.right = gamepad.is_currently_pressed(gamepads::Button::DPadRight);
        input.gamepad1.dpad.up = gamepad.is_currently_pressed(gamepads::Button::DPadUp);
        input.gamepad1.dpad.down = gamepad.is_currently_pressed(gamepads::Button::DPadDown);

        // shoulders
        input.gamepad1.shoulders.l1 =
            gamepad.is_currently_pressed(gamepads::Button::FrontLeftUpper);
        input.gamepad1.shoulders.r1 =
            gamepad.is_currently_pressed(gamepads::Button::FrontRightUpper);

        input.gamepad1.shoulders.l2 = gamepad.left_trigger();
        input.gamepad1.shoulders.r2 = gamepad.right_trigger();

        // sticks
        input.gamepad1.left_stick.x = gamepad.left_stick_x();
        input.gamepad1.left_stick.y = gamepad.left_stick_y();

        input.gamepad1.right_stick.x = gamepad.right_stick_x();
        input.gamepad1.right_stick.y = gamepad.right_stick_y();
        break;
    }
    input
}

pub fn draw(state: &mut State) {
    clear_background(Color::from_hex(0x081829));

    set_default_camera();
    let (w, h) = (SCREEN_WIDTH as f32 / 2., 400.0);

    set_camera(&Camera2D {
        zoom: vec2(2.2 / w, 2.2 / h),
        target: Vec2 { x: w / 2.2, y: 0.0 },
        viewport: Some((0, 0, w as i32, h as i32)),
        ..Default::default()
    });

    set_default_camera();

    match interpret::interpret(
        &mut state.state,
        "draw".into(),
        vec![ast::Expr::Value(state.game_state.clone())],
    ) {
        Ok(_) => {}
        Err(err) => println!("Error: {}", err),
    }
    draw_fps();

    /*
    println!(
        "{:#?}",
        interpret::value_to_stadnalone_expr(&state.state, state.game_state.clone())
    );
    */
}