/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   sort3.c                                            :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2024/02/08 15:50:10 by maiboyer          #+#    #+#             */
/*   Updated: 2024/02/08 17:53:02 by maiboyer         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

#include "app/state.h"
#include "me/types.h"
#include "me/vec/vec_i64.h"

void	push_a(void *s);
void	push_b(void *s);
void	swap_a(void *s);
void	swap_b(void *s);
void	swap_both(void *s);
void	rotate_a(void *s);
void	rotate_b(void *s);
void	rotate_both(void *s);
void	rev_rotate_a(void *s);
void	rev_rotate_b(void *s);
void	rev_rotate_both(void *s);

/*
fn	sort_three(state: &mut State, selector: StackSelector, min_first: bool) {
	macro_rules! stack {
		() => {
			match selector {
				StackSelector::B => &mut state.b,
				StackSelector::A => &mut state.a,
			}
		};
	}
	let [swap, rotate, rev_rotate] = match selector {
		StackSelector::A => [sa, ra, rra],
		StackSelector::B => [sb, rb, rrb],
	};
	match stack!().len() {
		2 => {
			let func = match min_first {
				true => PartialOrd::gt,
				false => PartialOrd::lt,
			};

			if func(&stack!()[0].clone(), &stack!()[1]) {
				swap(state);
			}
			return ;
		}
		3 => {}
		0 | 1 | 4.. => return,
	}
	let mut c = stack!().clone();
	macro_rules! comb {
		($i1:literal, $i2:literal, $i3:literal) => {
			&[c[$i1 - 1], c[$i2 - 1], c[$i3 - 1]]
		};
	}
	c.make_contiguous().sort_unstable();
	if min_first {
		c.make_contiguous().reverse();
	}
	stack!().make_contiguous();

		if (stack!() == 	comb![1, 2, 3]  / * abc * /)
{
	swap(state);
	rev_rotate(state);
}
else if (stack!() == comb ![ 1, 3, 2 ]  / * acb * /)
{
	rotate(state);
}
else if (stack !() == comb ![ 2, 3, 1 ] / * bca  * /)
{
	swap(state);
}
else if (stack !() == comb ![ 2, 1, 3 ] / * bac  * /)
{
	rotate(state);
}
else if (stack !() == comb ![ 3, 2, 1 ] / * cba  * /)
{
}
else if (stack !() == comb ![ 3, 1, 2 ] / * cab  * /)
{
	rotate(state);
	swap(state);
	rev_rotate(state);
}
}
*/
// 2 3 1
bool	sort_i64(t_i64 *lhs, t_i64 *rhs)
{
	return (*lhs <= *rhs);
}

void	sort_3_inner(t_state *state, t_i64 data[3], t_i64 sorted[3])
{
	if ((data[0] == sorted[0]) && (data[1] == sorted[1])
		&& (data[2] == sorted[2]))
		(swap_a(state), rev_rotate_a(state));
	else if ((data[0] == sorted[0]) && (data[1] == sorted[2])
		&& (data[2] == sorted[1]))
		rotate_a(state);
	else if ((data[0] == sorted[1]) && (data[1] == sorted[2])
		&& (data[2] == sorted[0]))
		swap_a(state);
	else if ((data[0] == sorted[1]) && (data[1] == sorted[0])
		&& (data[2] == sorted[2]))
		rev_rotate_a(state);
	else if ((data[0] == sorted[2]) && (data[1] == sorted[0])
		&& (data[2] == sorted[1]))
		(rotate_a(state), swap_a(state), rev_rotate_a(state));
}

void	sort_3(t_state *state)
{
	t_i64		array[3];
	t_vec_i64	why_do_i_do_this;

	why_do_i_do_this.free_func = NULL;
	why_do_i_do_this.len = 3;
	why_do_i_do_this.capacity = 3;
	why_do_i_do_this.buffer = array;
	array[0] = state->stack_a.buffer[0];
	array[1] = state->stack_a.buffer[1];
	array[2] = state->stack_a.buffer[2];
	vec_i64_sort(&why_do_i_do_this, sort_i64);
	vec_i64_reverse(&why_do_i_do_this);
	sort_3_inner(state, state->stack_a.buffer, array);
}