using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Numerics;

#nullable enable


sealed public record Vector3Cm( Cm x, Cm y, Cm z )
{
	public bool Equals( Vector3Cm? other ) => x == other?.x && y == other?.y && z == other?.z;

	public override int GetHashCode() => x.GetHashCode() * 10000019 + z.GetHashCode() * 50000047 + y.GetHashCode();

}






/// <summary>
/// Represents a fixed-point value in centimeters, stored as an integer.
/// Implements INumber<Cm> for full generic math support.
/// </summary>
sealed public record Cm( int value ) : INumber<Cm>
{
	// --- Constants and Identities ---

	/// <summary>
	/// Represents the multiplicative identity (1.0).
	/// The underlying value is 100 because 1.0 meter = 100 centimeters.
	/// </summary>
	public static Cm One => new Cm( 100 );
	public static Cm Zero => new Cm( 0 );
	public static int Radix => 10;
	public static Cm AdditiveIdentity => Zero;
	public static Cm MultiplicativeIdentity => One;


	public float Float => ( (float)value ) * 0.01f;
	public double Double => ( (double)value ) * 0.01;

	// --- Static Conversion Methods ---

	public static Cm From( float v ) => new Cm( (int)( v * 100.0f + 0.5f ) );
	public static Cm From( double v ) => new Cm( (int)( v * 100.0 + 0.5 ) );


	// --- Standard Functions ---

	public static Cm Abs( Cm c ) => new Cm( Math.Abs( c.value ) );
	public static Cm MaxMagnitude( Cm x, Cm y ) => Abs( x ) > Abs( y ) ? x : y;
	public static Cm MaxMagnitudeNumber( Cm x, Cm y ) => MaxMagnitude( x, y ); // Same for this type
	public static Cm MinMagnitude( Cm x, Cm y ) => Abs( x ) < Abs( y ) ? x : y;
	public static Cm MinMagnitudeNumber( Cm x, Cm y ) => MinMagnitude( x, y ); // Same for this type

	// --- Type Property Checks ---

	public static bool IsCanonical( Cm c ) => true;
	public static bool IsComplexNumber( Cm c ) => false;
	public static bool IsEvenInteger( Cm c ) => ( c.value % 100 == 0 ) && ( c.value / 100 % 2 == 0 );
	public static bool IsFinite( Cm c ) => true;
	public static bool IsImaginaryNumber( Cm c ) => false;
	public static bool IsInfinity( Cm c ) => false;
	public static bool IsInteger( Cm c ) => c.value % 100 == 0;
	public static bool IsNaN( Cm c ) => false;
	public static bool IsNegative( Cm c ) => c.value < 0;
	public static bool IsNegativeInfinity( Cm c ) => false;
	public static bool IsNormal( Cm c ) => c.value != 0;
	public static bool IsOddInteger( Cm c ) => ( c.value % 100 == 0 ) && ( c.value / 100 % 2 != 0 );
	public static bool IsPositive( Cm c ) => c.value > 0;
	public static bool IsPositiveInfinity( Cm c ) => false;
	public static bool IsRealNumber( Cm c ) => true; // It is a real number
	public static bool IsSubnormal( Cm c ) => false;
	public static bool IsZero( Cm c ) => c.value == 0;

	// --- Parsing ---

	public static Cm Parse( string s, IFormatProvider? provider ) => Parse( s, NumberStyles.Number, provider );
	public static Cm Parse( ReadOnlySpan<char> s, IFormatProvider? provider ) => Parse( s, NumberStyles.Number, provider );
	public static Cm Parse( string s, NumberStyles style, IFormatProvider? provider )
	{
		if( TryParse( s, style, provider, out var result ) )
		{
			return result;
		}
		throw new FormatException( $"Input string '{s}' was not in a correct format." );
	}
	public static Cm Parse( ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider )
	{
		if( TryParse( s, style, provider, out var result ) )
		{
			return result;
		}
		throw new FormatException( $"Input string was not in a correct format." );
	}

	public static bool TryParse( [NotNullWhen( true )] string? s, IFormatProvider? provider, [MaybeNullWhen( false )] out Cm result ) => TryParse( s, NumberStyles.Number, provider, out result );
	public static bool TryParse( ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen( false )] out Cm result ) => TryParse( s, NumberStyles.Number, provider, out result );
	public static bool TryParse( [NotNullWhen( true )] string? s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen( false )] out Cm result )
	{
		if( decimal.TryParse( s, style, provider, out decimal decValue ) )
		{
			result = new Cm( (int)( decValue * 100m ) );
			return true;
		}
		result = Cm.Zero;
		return false;
	}
	public static bool TryParse( ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen( false )] out Cm result )
	{
		if( decimal.TryParse( s, style, provider, out decimal decValue ) )
		{
			result = new Cm( (int)( decValue * 100m ) );
			return true;
		}
		result = Cm.Zero;
		return false;
	}

	// --- Generic Type Conversion ---

	public static bool TryConvertFromChecked<TOther>( TOther value, out Cm result ) where TOther : INumberBase<TOther>
	{
		// For integer types, scale up. For floating point, convert.
		if( TOther.IsInteger( value ) )
		{
			try
			{
				checked
				{
					result = new Cm( int.CreateChecked( value ) * 100 );
					return true;
				}
			}
			catch( OverflowException )
			{
				result = Cm.Zero;
				return false;
			}
		}

		// Convert floating point types
		if( typeof( TOther ) == typeof( double ) )
		{
			double d = double.CreateChecked( value );
			result = From( d );
			return true;
		}
		if( typeof( TOther ) == typeof( float ) )
		{
			float f = float.CreateChecked( value );
			result = From( f );
			return true;
		}
		if( typeof( TOther ) == typeof( decimal ) )
		{
			decimal m = decimal.CreateChecked( value );
			result = new Cm( (int)( m * 100m ) );
			return true;
		}

		result = Cm.Zero;
		return false;
	}

	public static bool TryConvertFromSaturating<TOther>( TOther value, out Cm result ) where TOther : INumberBase<TOther>
	{
		if( TOther.IsInteger( value ) )
		{
			result = new Cm( int.CreateSaturating( value ) * 100 );
			return true;
		}
		if( typeof( TOther ) == typeof( double ) )
		{
			double d = double.CreateSaturating( value );
			result = From( d );
			return true;
		}
		if( typeof( TOther ) == typeof( float ) )
		{
			float f = float.CreateSaturating( value );
			result = From( f );
			return true;
		}
		if( typeof( TOther ) == typeof( decimal ) )
		{
			decimal m = decimal.CreateSaturating( value );
			result = new Cm( (int)( m * 100m ) );
			return true;
		}
		result = Cm.Zero;
		return false;
	}

	public static bool TryConvertFromTruncating<TOther>( TOther value, out Cm result ) where TOther : INumberBase<TOther>
	{
		if( TOther.IsInteger( value ) )
		{
			result = new Cm( int.CreateTruncating( value ) * 100 );
			return true;
		}
		if( typeof( TOther ) == typeof( double ) )
		{
			double d = double.CreateTruncating( value );
			result = From( d );
			return true;
		}
		if( typeof( TOther ) == typeof( float ) )
		{
			float f = float.CreateTruncating( value );
			result = From( f );
			return true;
		}
		if( typeof( TOther ) == typeof( decimal ) )
		{
			decimal m = decimal.CreateTruncating( value );
			result = new Cm( (int)( m * 100m ) );
			return true;
		}
		result = Cm.Zero;
		return false;
	}

	public static bool TryConvertToChecked<TOther>( Cm value, out TOther result ) where TOther : INumberBase<TOther>
	{
		// Convert our value (a count of centimeters) to another type.
		// This typically involves scaling down by 100.
		try
		{
			checked
			{
				if( TOther.IsInteger( TOther.Zero ) )
				{
					result = TOther.CreateChecked( value.value / 100 );
					return true;
				}

				// For floating points, perform floating point division
				result = TOther.CreateChecked( value.value ) / TOther.CreateChecked( 100 );
				return true;
			}
		}
		catch( OverflowException )
		{
			result = default!;
			return false;
		}
	}

	public static bool TryConvertToSaturating<TOther>( Cm value, out TOther result ) where TOther : INumberBase<TOther>
	{
		if( TOther.IsInteger( TOther.Zero ) )
		{
			result = TOther.CreateSaturating( value.value / 100 );
			return true;
		}
		result = TOther.CreateSaturating( value.value ) / TOther.CreateSaturating( 100 );
		return true;
	}

	public static bool TryConvertToTruncating<TOther>( Cm value, out TOther result ) where TOther : INumberBase<TOther>
	{
		if( TOther.IsInteger( TOther.Zero ) )
		{
			result = TOther.CreateTruncating( value.value / 100 );
			return true;
		}
		result = TOther.CreateTruncating( value.value ) / TOther.CreateTruncating( 100 );
		return true;
	}

	// --- Comparison ---

	public int CompareTo( object? obj )
	{
		if( obj is Cm other )
		{
			return CompareTo( other );
		}
		return obj is null ? 1 : throw new ArgumentException( "Object must be of type Cm.", nameof( obj ) );
	}

	public int CompareTo( Cm? other ) => value.CompareTo( other?.value );

	public bool Equals( Cm? other ) => value == other?.value;

	public override int GetHashCode() => value.GetHashCode();

	// --- Formatting ---

	public override string ToString() => ( value / 100.0 ).ToString( "F2", CultureInfo.InvariantCulture );

	public string ToString( string? format, IFormatProvider? formatProvider )
	{
		// Format as a floating point number
		return ( value / 100.0 ).ToString( format, formatProvider );
	}

	public bool TryFormat( Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider )
	{
		return ( value / 100.0 ).TryFormat( destination, out charsWritten, format, provider );
	}

	// --- Operators ---

	public static Cm operator +( Cm c ) => c;
	public static Cm operator +( Cm left, Cm right ) => new Cm( left.value + right.value );
	public static Cm operator -( Cm c ) => new Cm( -c.value );
	public static Cm operator -( Cm left, Cm right ) => new Cm( left.value - right.value );
	public static Cm operator ++( Cm c ) => new Cm( c.value + 1 );
	public static Cm operator --( Cm c ) => new Cm( c.value - 1 );

	// For fixed-point, multiplication/division require scaling
	public static Cm operator *( Cm left, Cm right )
	{
		// (a/100) * (b/100) = (a*b)/10000. To get back to our format, multiply by 100.
		// So, (a*b)/100. Use long to prevent intermediate overflow.
		return new Cm( (int)( ( (long)left.value * right.value ) / 100 ) );
	}

	public static Cm operator /( Cm left, Cm right )
	{
		// (a/100) / (b/100) = a/b. To get back to our format, multiply by 100.
		// So, (a*100)/b. Use long to prevent intermediate overflow.
		return new Cm( (int)( ( (long)left.value * 100 ) / right.value ) );
	}

	public static Cm operator %( Cm left, Cm right ) => new Cm( left.value % right.value );

	// --- Comparison Operators ---
	public static bool operator <( Cm left, Cm right ) => left.value < right.value;
	public static bool operator >( Cm left, Cm right ) => left.value > right.value;
	public static bool operator <=( Cm left, Cm right ) => left.value <= right.value;
	public static bool operator >=( Cm left, Cm right ) => left.value >= right.value;
}

/// <summary>
/// Provides extension methods for easy conversion to the Cm type.
/// </summary>
public static class CentEx
{

	// --- Static Conversion Methods ---

	public static Cm From( float v ) => new Cm( (int)( v * 100.0f + 0.5f ) );
	public static Cm From( double v ) => new Cm( (int)( v * 100.0 + 0.5 ) );


	//public static Cm Cm(this float r) => CentEx.From(r);
	//public static Cm Cm(this double r) => CentEx.From(r);


	extension( float r )
	{
		public Cm Cm => CentEx.From( r );
	}

	extension( double r )
	{
		public Cm Cm => CentEx.From( r );
	}

}