use urt_gameplay::client_processing::*;
fn hex(v: &[u8]) -> String {
    v.iter().map(|v| format!("{v:02x}")).collect()
}
fn list(v: &[u32]) -> String {
    format!(
        "[{}]",
        v.iter()
            .map(|v| v.to_string())
            .collect::<Vec<_>>()
            .join(",")
    )
}
fn events(v: &[ProcessingEffect]) -> String {
    v.iter()
        .map(|e| match e {
            ProcessingEffect::Intermission { slot } => {
                format!(r#"{{"op":"intermission","slot":{}}}"#, slot)
            }
            ProcessingEffect::Spectator { slot, command_time } => format!(
                r#"{{"op":"spectator","slot":{},"command_time":{}}}"#,
                slot, command_time
            ),
            ProcessingEffect::Team { slot, text, force } => format!(
                r#"{{"op":"team","slot":{},"text":"{}","force":{}}}"#,
                slot,
                hex(text),
                force
            ),
            ProcessingEffect::Send { slot, text } => {
                format!(r#"{{"op":"send","slot":{},"text":"{}"}}"#, slot, hex(text))
            }
            ProcessingEffect::Drop { slot, text } => {
                format!(r#"{{"op":"drop","slot":{},"text":"{}"}}"#, slot, hex(text))
            }
        })
        .collect::<Vec<_>>()
        .join(",")
}
fn main() {
    let mut args = std::env::args().skip(1);
    let kind = args.next().unwrap();
    let w: Vec<u32> = args.map(|v| v.parse().unwrap()).collect();
    match kind.as_str() {
        "route" => {
            assert_eq!(w.len(), 4);
            let out = route_client(RoutingInput {
                intermission: w[0],
                team: w[1],
                follow: w[2],
                spectator: w[3],
                slot: 2,
                command_time: 12345,
            })
            .unwrap();
            println!(
                r#"{{"events":[{}],"proceed":{}}}"#,
                events(&out.effects),
                out.route == ClientRoute::Continue
            );
        }
        "command" => {
            assert_eq!(w.len(), 13);
            let mut state = CommandState {
                angles: w[4..7].try_into().unwrap(),
                saved: w[7..10].try_into().unwrap(),
                buttons: w[10],
                move_word: w[11],
            };
            rewrite_client_command(
                &mut state,
                CommandControl {
                    pause: w[0],
                    mode: w[1],
                    flags: w[2],
                    block: w[3],
                },
            );
            println!(
                r#"{{"angles":{},"saved":{},"buttons":{},"move_word":{},"command_time":{}}}"#,
                list(&state.angles),
                list(&state.saved),
                state.buttons,
                state.move_word,
                w[12]
            );
        }
        "idle" => {
            assert_eq!(w.len(), 16);
            let mut state = InactivityState {
                deadline: w[12],
                warned: w[13],
            };
            let out = client_inactivity(
                &mut state,
                InactivityInput {
                    entity_flags: w[0],
                    idle_seconds: w[1],
                    pause: w[2],
                    pause_anchor: w[3],
                    tick: w[4],
                    moves: [w[5] as u8, w[6] as u8, w[7] as u8],
                    buttons: w[8],
                    health: w[9],
                    exempt: w[10],
                    mode: w[11],
                    msec: w[14],
                    slot: 2,
                },
            )
            .unwrap();
            assert_eq!(w[15], 2);
            println!(
                r#"{{"accepted":{},"events":[{}],"deadline":{},"warned":{},"health":{}}}"#,
                out.accepted,
                events(&out.effects),
                state.deadline,
                state.warned,
                w[9]
            );
        }
        "movement" => {
            assert_eq!(w.len(), 11);
            let mut state = MovementState {
                pm_type: 99,
                gravity: 111,
                speed: 222,
                controller: w[3] != 0,
                packed: [333, 444],
                event_sequence: w[10],
            };
            let seq = setup_client_movement(
                &mut state,
                MovementInput {
                    pause: w[0],
                    noclip: w[1],
                    health: w[2],
                    gravity: w[4],
                    factor: w[5],
                    packs: w[6..10].try_into().unwrap(),
                },
            )
            .unwrap();
            println!(
                r#"{{"pm_type":{},"gravity_word":{},"speed":{},"controller":{},"packed":{},"event_sequence":{}}}"#,
                state.pm_type,
                state.gravity,
                state.speed,
                u8::from(state.controller),
                list(&state.packed),
                seq
            );
        }
        "pipeline" => println!("{}", pipeline(&w)),
        _ => panic!("unknown policy"),
    }
}

fn optional(v: Option<u32>) -> String {
    v.map(|v| v.to_string()).unwrap_or("null".into())
}
fn optional_bool(v: Option<bool>) -> String {
    v.map(|v| v.to_string()).unwrap_or("null".into())
}
fn pipeline(w: &[u32]) -> String {
    assert_eq!(w.len(), 38);
    let mut s = ClientProcessingState {
        timing: urt_gameplay::client_timer::TimerPrepareState {
            connection: w[0],
            exception: w[1],
            command_time: w[2],
            current_time: w[3],
            quantize: w[4],
            copied_tick: 17,
            copied_command: 18,
        },
        command: CommandState {
            angles: w[27..30].try_into().unwrap(),
            saved: w[30..33].try_into().unwrap(),
            buttons: w[25],
            move_word: w[26],
        },
        inactivity: InactivityState {
            deadline: w[23],
            warned: w[24],
        },
        movement: MovementState {
            pm_type: 99,
            gravity: 111,
            speed: 222,
            controller: w[20] != 0,
            packed: [333, 444],
            event_sequence: w[37],
        },
    };
    let input = ClientProcessingInput {
        slot: 2,
        tick: w[5],
        intermission: w[6],
        team: w[7],
        follow: w[8],
        pause: w[9],
        game_mode: w[10],
        client_flags: w[11],
        block: w[12],
        entity_flags: w[13],
        idle_seconds: w[14],
        pause_anchor: w[15],
        health: w[16],
        exempt: w[17],
        idle_mode: w[18],
        noclip: w[19],
        gravity: w[21],
        factor: w[22],
        packs: w[33..37].try_into().unwrap(),
    };
    let out = client_pre_movement(&mut s, input).unwrap();
    let command = format!(
        r#"{{"angles":{},"saved":{},"buttons":{},"move_word":{},"command_time":{}}}"#,
        list(&s.command.angles),
        list(&s.command.saved),
        s.command.buttons,
        s.command.move_word,
        s.timing.command_time
    );
    let movement = format!(
        r#"{{"pm_type":{},"gravity_word":{},"speed":{},"controller":{},"packed":{},"event_sequence":{}}}"#,
        s.movement.pm_type,
        s.movement.gravity,
        s.movement.speed,
        u8::from(s.movement.controller),
        list(&s.movement.packed),
        optional(out.event_sequence)
    );
    format!(
        r#"{{"proceed":{},"events":[{}],"msec":{},"idle_result":{},"idle_msec":{},"timing":{},"command":{},"idle_state":{},"movement":{},"health":{}}}"#,
        out.proceed,
        events(&out.effects),
        optional(out.msec),
        optional_bool(out.idle_result),
        optional(out.idle_msec),
        list(&[
            s.timing.command_time,
            s.timing.current_time,
            s.timing.copied_tick,
            s.timing.copied_command
        ]),
        command,
        list(&[s.inactivity.deadline, s.inactivity.warned]),
        movement,
        w[16]
    )
}