// SPDX-License-Identifier: LGPL-2.1-only
// Copyright (C) 2026 Liberux Labs, S. L. <info@liberux.net>

use crate::types::Rect;
use crate::render::Canvas;
use crate::widget::Element;

/// A horizontal layout container.
///
/// Children are arranged left-to-right. Use [`Row::align_right`] to
/// push the content block to the right edge of the available width.
///
/// ```rust,no_run
/// # use std::sync::Arc;
/// # use ltk::{ icon_button, row, Element };
/// # #[ derive( Clone ) ] enum Msg { A, B }
/// # fn _ex( a_rgba: Arc<Vec<u8>>, b_rgba: Arc<Vec<u8>>, w: u32, h: u32 ) -> Element<Msg> {
/// row()
///     .spacing( 16.0 )
///     .align_right()
///     .push( icon_button( a_rgba, w, h ).on_press( Msg::A ) )
///     .push( icon_button( b_rgba, w, h ).on_press( Msg::B ) )
/// .into()
/// # }
/// ```
pub struct Row<Msg: Clone>
{
	pub children:    Vec<Element<Msg>>,
	pub spacing:     f32,
	pub padding:     f32,
	pub align_right: bool,
}

impl<Msg: Clone> Row<Msg>
{
	pub fn new() -> Self
	{
		Self { children: Vec::new(), spacing: 8.0, padding: 0.0, align_right: false }
	}

	/// Append a child widget or layout.
	pub fn push( mut self, e: impl Into<Element<Msg>> ) -> Self
	{
		self.children.push( e.into() );
		self
	}

	/// Set the horizontal gap between children in pixels. Default: `8.0`.
	pub fn spacing( mut self, s: f32 ) -> Self
	{
		self.spacing = s;
		self
	}

	/// Set the padding (all sides) in pixels. Default: `0.0`.
	pub fn padding( mut self, p: f32 ) -> Self
	{
		self.padding = p;
		self
	}

	/// Push the content block to the right edge of the available width.
	pub fn align_right( mut self ) -> Self
	{
		self.align_right = true;
		self
	}

	/// Return the preferred `(width, height)` given available `max_width`.
	pub fn preferred_size( &self, max_width: f32, canvas: &Canvas ) -> (f32, f32)
	{
		// Width contribution of every fixed (non-flex, non-flex-spacer) child.
		// Used to compute the residual width that wrap-style children will
		// actually render in, so their reported height matches the layout.
		let inner_w = ( max_width - self.padding * 2.0 ).max( 0.0 );
		let gaps    = self.spacing * self.children.len().saturating_sub( 1 ) as f32;
		let fixed_w: f32 = self.children.iter()
			.filter( |c| match c
			{
				Element::Flex( _ )   => false,
				Element::Spacer( s ) => s.fixed_width.is_some(),
				_                    => true,
			} )
			.map( |c| c.preferred_size( max_width, canvas ).0 )
			.sum();
		let residual = ( inner_w - fixed_w - gaps ).max( 0.0 );

		let max_h: f32 = self.children.iter()
			.map( |c| match c
			{
				Element::Flex( _ )   => c.preferred_size( residual, canvas ).1,
				Element::Spacer( _ ) => c.preferred_size( max_width, canvas ).1,
				_                    => c.preferred_size( max_width, canvas ).1,
			} )
			.fold( 0.0_f32, f32::max );

		// `align_right` and any flex / weight-only spacer child make the row
		// claim the full `max_width`: in those cases the row's rendered width
		// comes from leftover distribution (or the right-edge anchor), not
		// from the sum of children's preferred widths. Reporting only the
		// natural sum would leave the parent allocating a too-narrow rect and
		// the flex children would collapse to 0.
		let has_flex = self.children.iter().any( |c| match c
		{
			Element::Flex( _ )   => true,
			Element::Spacer( s ) => s.fixed_width.is_none(),
			_                    => false,
		} );

		let w = if self.align_right || has_flex
		{
			max_width
		} else {
			let total_w: f32 = self.children.iter()
				.map( |c| c.preferred_size( max_width, canvas ).0 )
				.sum::<f32>()
				+ gaps
				+ self.padding * 2.0;
			total_w.min( max_width )
		};

		( w, max_h + self.padding * 2.0 )
	}

	pub fn draw( &self, _canvas: &mut Canvas, _rect: Rect, _focused: bool ) {}

	/// Layout children within rect and return `(rect, child_index)` pairs.
	///
	/// Flexible [`Spacer`](crate::layout::spacer::Spacer) children claim the
	/// leftover horizontal space: non-spacer widgets keep their preferred
	/// width, the remaining width (after subtracting spacing + padding) is
	/// distributed between spacers in proportion to their `weight`. When no
	/// spacers are present the cluster is centered (or right-aligned via
	/// [`Row::align_right`]).
	pub fn layout( &self, rect: Rect, canvas: &Canvas ) -> Vec<(Rect, usize)>
	{
		let inner_h = rect.height - self.padding * 2.0;

		// Spacers and `Flex` wrappers report 0 width here; their real width
		// comes from the flex distribution below.
		let sizes: Vec<(f32, f32)> = self.children.iter()
			.map( |c| c.preferred_size( rect.width, canvas ) )
			.collect();

		let gaps = self.spacing * self.children.len().saturating_sub( 1 ) as f32;
		let fixed_w: f32 = self.children.iter().zip( sizes.iter() )
			.filter( |( c, _ )| match c
			{
				// Pure flex children (`Flex` and weight-only `Spacer`) take
				// width from the leftover pool; everything else, including
				// `Spacer::width(...)`-pinned spacers, contributes to the
				// fixed-width tally.
				Element::Flex( _ )   => false,
				Element::Spacer( s ) => s.fixed_width.is_some(),
				_                    => true,
			} )
			.map( |( _, ( w, _ ) )| *w )
			.sum();

		let total_weight: u32 = self.children.iter()
			.filter_map( |c| match c {
				Element::Spacer( s ) if s.fixed_width.is_none() => Some( s.weight ),
				Element::Flex( f )   => Some( f.weight ),
				_                    => None,
			} )
			.sum();

		let inner_w     = ( rect.width - self.padding * 2.0 ).max( 0.0 );
		let leftover    = ( inner_w - fixed_w - gaps ).max( 0.0 );
		let has_spacers = total_weight > 0;

		let ( start_x, flex_unit ) = if has_spacers
		{
			// Spacers and `Flex` wrappers claim the leftover; the cluster
			// sits flush to the left edge of the inner rect.
			( rect.x + self.padding, leftover / total_weight as f32 )
		}
		else if self.align_right
		{
			( rect.x + rect.width - (fixed_w + gaps) - self.padding, 0.0 )
		}
		else
		{
			( rect.x + (rect.width - fixed_w - gaps) / 2.0, 0.0 )
		};

		let mut x = start_x;
		let mut result = Vec::with_capacity( self.children.len() );
		for ( i, ( (w, h), child) ) in sizes.into_iter().zip( self.children.iter() ).enumerate()
		{
			let width = match child
			{
				Element::Spacer( s ) => match s.fixed_width
				{
					Some( fw ) => fw,
					None       => flex_unit * s.weight as f32,
				},
				Element::Flex( f )   => flex_unit * f.weight as f32,
				_                    => w,
			};
			let y = rect.y + self.padding + (inner_h - h) / 2.0;
			result.push( ( Rect { x, y, width, height: h }, i ) );
			x += width + self.spacing;
		}
		result
	}

	pub( crate ) fn map_msg<U>( self, f: &crate::widget::MapFn<Msg, U> ) -> Row<U>
	where
		U: Clone + 'static,
		Msg: 'static,
	{
		Row
		{
			children:    self.children.into_iter().map( |c| c.map_arc( f ) ).collect(),
			spacing:     self.spacing,
			padding:     self.padding,
			align_right: self.align_right,
		}
	}
}

/// Create an empty row layout.
pub fn row<Msg: Clone>() -> Row<Msg>
{
	Row::new()
}

impl<Msg: Clone> Default for Row<Msg>
{
	fn default() -> Self
	{
		Self::new()
	}
}

#[ cfg( test ) ]
mod tests
{
	use super::*;
	use crate::render::Canvas;
	use crate::types::Rect;

	fn make_canvas() -> Canvas { Canvas::new( 800, 600 ) }

	#[ test ]
	fn align_right_returns_full_max_width()
	{
		let canvas = make_canvas();
		let r      = row::<()>().align_right();
		let ( w, _ ) = r.preferred_size( 500.0, &canvas );
		assert_eq!( w, 500.0 );
	}

	#[ test ]
	fn align_right_true_regardless_of_children()
	{
		let canvas = make_canvas();
		let r = row::<()>().align_right().spacing( 999.0 );
		let ( w, _ ) = r.preferred_size( 300.0, &canvas );
		assert_eq!( w, 300.0 );
	}

	#[ test ]
	fn centered_empty_row_returns_zero_width()
	{
		let canvas = make_canvas();
		let r      = row::<()>();
		let ( w, _ ) = r.preferred_size( 500.0, &canvas );
		assert_eq!( w, 0.0 );
	}

	#[ test ]
	fn centered_empty_row_returns_zero_height()
	{
		let canvas = make_canvas();
		let r      = row::<()>().padding( 0.0 );
		let ( _, h ) = r.preferred_size( 500.0, &canvas );
		assert_eq!( h, 0.0 );
	}

	#[ test ]
	fn padding_adds_to_height()
	{
		let canvas = make_canvas();
		let r      = row::<()>().padding( 8.0 );
		let ( _, h ) = r.preferred_size( 500.0, &canvas );
		assert_eq!( h, 16.0 );
	}

	#[ test ]
	fn layout_of_empty_row_is_empty()
	{
		let canvas = make_canvas();
		let r      = row::<()>().align_right();
		let rect   = Rect { x: 0., y: 0., width: 400., height: 48. };
		assert!( r.layout( rect, &canvas ).is_empty() );
	}
}