#include "builtins/builtins.h"
#include "precedence.h"
#include "helpers.h"
#include "tuple.h"

using namespace goose;
using namespace goose::ir;
using namespace goose::llr;
using namespace goose::parse;

namespace goose::builtins
{
    void SetupLogicOps( Env& e )
    {
        BuildParseRule( e, "!"_sid,
            PrefixOp( "operator_logical_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                ForType< bool >( []( auto&& operand ) -> Value
                {
                    return BuildComputedValue( GetValueType< bool >(),
                        Xor( operand, ToValue( true ) ) );
                } )
            )
        );

        BuildParseRule( e, "~"_sid,
            PrefixOp( "operator_bitwise_not"_sid, precedence::UnaryOps,
                BuildGenericTupleOperator(),

                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >( []( auto&& operand ) -> Value
                {
                    auto opTypeVal = *ValueFromIRExpr( operand.type() );
                    auto opType = *FromValue< IntegerType >( opTypeVal );
                    return BuildComputedValue( operand.type(),
                        Xor( operand,
                            Value( operand.type(), APSInt::getMaxValue( opType.m_numBits, true ) )
                        ) );
                } )
            )
        );

        BuildParseRule( e, "^"_sid,
            LeftAssInfixOp( "operator_xor"_sid, precedence::OrOp,
                BuildGenericTupleOperator(),

                // Logical xor
                ForType< bool, Xor >(),

                // ct_int xor
                ForType< BigInt, Xor >(),

                // runtime integer xor, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        Xor( lhs, rhs ) );
                } )
            )
        );

        BuildParseRule( e, "|"_sid,
            LeftAssInfixOp( "operator_or"_sid, precedence::OrOp,
                BuildGenericTupleOperator(),

                // ct_int or
                ForType< BigInt, Or >(),

                // runtime integer or, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        Or( lhs, rhs ) );
                } ),

                // verification expressions bool or
                ForVerificationType< bool, Or >(),

                // bool or
                ForType< bool >( []( auto&& lhs, auto&& rhs ) -> Value
                {
                    // Build a CFG that implements the control flow for
                    // shortcut evaluation.
                    auto cfg = make_shared< CFG >();
                    auto pLhsBB = cfg->entryBB();
                    auto pRhsBB = cfg->createBB();
                    auto pEndBB = cfg->createBB();

                    // If the lhs is true, skip to the end directly.
                    // Otherwise, jump to the BB that computes rhs.
                    pLhsBB->setTerminator( CondBranch( lhs, pEndBB, pRhsBB ) );

                    auto rhsIndex = cfg->getNewTemporaryIndex();
                    pRhsBB->emplace_back( CreateTemporary( cfg->uniqueId(), rhsIndex, rhs ) );
                    pRhsBB->setTerminator( Branch( pEndBB ) );

                    auto resultIndex = cfg->getNewTemporaryIndex();

                    // Build the Phi instruction that will collect the final result.
                    auto phi = Phi( *ValueFromIRExpr( GetValueType< bool >() ),
                        2, cfg->uniqueId(), resultIndex );

                    // If coming directly from the lhs BB, we know the result is true.
                    phi.setIncoming( pLhsBB, ToValue( true ) );

                    // Otherwise, the result is whatever was computed by the rhs block.
                    phi.setIncoming( pRhsBB, BuildComputedValue( GetValueType< bool >(),
                        GetTemporary( cfg->uniqueId(), rhsIndex ) ) );

                    pEndBB->emplace_back( move( phi ) );

                    // Build the result val which pulls the temporary created by the
                    // cfg above.
                    auto resultVal = BuildComputedValue( GetValueType< bool >(),
                        GetTemporary( cfg->uniqueId(), resultIndex ) );

                    // Return it
                    pEndBB->setTerminator( Ret( move( resultVal ) ) );

                    // Pachage our cfg in a value with an inline CFG instruction.
                    return BuildComputedValue( GetValueType< bool >(), move( cfg ) );
                } )
            )
        );

        BuildParseRule( e, "&"_sid,
            LeftAssInfixOp( "operator_and"_sid, precedence::AndOp,
                BuildGenericTupleOperator(),

                // ct_int and
                ForType< BigInt, And >(),

                // runtime integer and, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        And( lhs, rhs ) );
                } ),

                // verification expressions bool and
                ForVerificationType< bool, And >(),

                // bool and
                ForType< bool >( []( auto&& lhs, auto&& rhs ) -> Value
                {
                    // Build a CFG that implements the control flow for
                    // shortcut evaluation.
                    auto cfg = make_shared< CFG >();
                    auto pLhsBB = cfg->entryBB();
                    auto pRhsBB = cfg->createBB();
                    auto pEndBB = cfg->createBB();

                    // If the lhs is false, skip to the end directly.
                    // Otherwise, jump to the BB that computes rhs.
                    pLhsBB->setTerminator( CondBranch( lhs, pRhsBB, pEndBB ) );

                    auto rhsIndex = cfg->getNewTemporaryIndex();
                    pRhsBB->emplace_back( CreateTemporary( cfg->uniqueId(), rhsIndex, rhs ) );
                    pRhsBB->setTerminator( Branch( pEndBB ) );

                    auto resultIndex = cfg->getNewTemporaryIndex();

                    // Build the Phi instruction that will collect the final result.
                    auto phi = Phi( *ValueFromIRExpr( GetValueType< bool >() ),
                        2, cfg->uniqueId(), resultIndex );

                    // If coming directly from the lhs BB, we know the result is false.
                    phi.setIncoming( pLhsBB, ToValue( false ) );

                    // Otherwise, the result is whatever was computed by the rhs block.
                    phi.setIncoming( pRhsBB, BuildComputedValue( GetValueType< bool >(),
                        GetTemporary( cfg->uniqueId(), rhsIndex ) ) );

                    pEndBB->emplace_back( move( phi ) );

                    // Build the result val which pulls the temporary created by the
                    // cfg above.
                    auto resultVal = BuildComputedValue( GetValueType< bool >(),
                        GetTemporary( cfg->uniqueId(), resultIndex ) );

                    // Return it
                    pEndBB->setTerminator( Ret( move( resultVal ) ) );

                    // Pachage our cfg in a value with an inline CFG instruction.
                    return BuildComputedValue( GetValueType< bool >(), move( cfg ) );
                } )
            )
        );

        BuildParseRule( e, "<<"_sid,
            LeftAssInfixOp( "operator_shift_left"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int left shift
                ForTypes< BigInt, uint32_t >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        Shl( lhs, rhs ) );
                } ),

                // runtime integer left shift, defined to work for any two integers of same
                // bit size and signedness.
                ForType< CustomPattern< IntegerType, IntegerType::Pattern > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        Shl( lhs, rhs ) );
                } )
            )
        );

        BuildParseRule( e, ">>"_sid,
            LeftAssInfixOp( "operator_shift_right"_sid, precedence::BitShiftOp,
                BuildGenericTupleOperator(),

                // ct_int right shift
                ForTypes< BigInt, uint32_t >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        AShr( lhs, rhs ) );
                } ),

                // runtime signed integer right shift, defined to work for any two integers of same
                // bit size.
                ForType< CustomPattern< IntegerType, IntegerType::PatternSigned > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        AShr( lhs, rhs ) );
                } ),

                // runtime unsigned integer right shift, defined to work for any two integers of same
                // bit size.
                ForType< CustomPattern< IntegerType, IntegerType::PatternUnsigned > >(
                []( auto&& lhs, auto&& rhs ) -> Value
                {
                    return BuildComputedValue( lhs.type(),
                        LShr( lhs, rhs ) );
                } )
            )
        );
    }
}
