#include "core/blob.h"
#include "core/graph_match.h"
#include "core/runtime.h"
#include "operators/concat.h"
#include "operators/conv.h"
#include "operators/element_wise.h"
#include "operators/extend.h"
#include "operators/pad.h"
#include "operators/pooling.h"
#include "operators/reduce_mean.h"
#include "operators/slice.h"
#include "operators/split.h"
#include "operators/unary.h"
#include "test.h"
namespace infini {
// hrnet48 head   match conv-relu
TEST(SubGraphRewriter, subGraphMatch1) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    Graph g = make_ref<GraphObj>(runtime);
    Tensor i0 = g->addTensor({1, 3, 244, 244}, DataType::UInt32);
    Tensor w0 = g->addTensor({64, 3, 3, 3}, DataType::UInt32);
    auto conv = g->addOp<ConvObj>(i0, w0, nullptr);
    auto relu = g->addOp<ReluObj>(conv->getOutput(), nullptr);

    auto w1 = g->addTensor({64, 64, 3, 3}, DataType::UInt32);
    auto conv1 = g->addOp<ConvObj>(relu->getOutput(0), w1, nullptr);
    auto relu1 = g->addOp<ReluObj>(conv1->getOutput(), nullptr);

    auto w2 = g->addTensor({64, 64, 1, 1}, DataType::UInt32);
    auto conv2 = g->addOp<ConvObj>(relu1->getOutput(0), w2, nullptr);
    auto relu2 = g->addOp<ReluObj>(conv2->getOutput(), nullptr);

    auto w3 = g->addTensor({256, 64, 1, 1}, DataType::UInt32);
    auto conv3 = g->addOp<ConvObj>(relu1->getOutput(0), w3, nullptr);

    auto w4 = g->addTensor({64, 64, 3, 3}, DataType::UInt32);
    auto conv4 = g->addOp<ConvObj>(relu2->getOutput(0), w4, nullptr);
    auto relu4 = g->addOp<ReluObj>(conv4->getOutput(), nullptr);

    Tensor si0 =
        make_ref<TensorObj>(Shape{1, 64, 112, 112}, DataType::UInt32, runtime);
    SubGraph subG = make_ref<SubGraphObj>(runtime, TensorVec{si0});
    Tensor sw0 = subG->addTensor({64, 64, 3, 3}, DataType::UInt32);
    auto sconv0 = subG->addOp<ConvObj>(si0, sw0, nullptr);
    auto srelu0 = subG->addOp<ReluObj>(sconv0->getOutput(), nullptr);
    subG->setOutputs(srelu0->getOutputs());

    SubGraphRewriter v(g);
    vector<MatchGraph> subgs = v.findMatch(subG);

    EXPECT_TRUE(subgs.size() == 2u);
}

TEST(MatchGraph, single_input) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    // subG0
    Tensor si0 =
        make_ref<TensorObj>(Shape{1, 96, 28, 28}, DataType::UInt32, runtime);
    SubGraph subG = make_ref<SubGraphObj>(runtime, TensorVec{si0});
    {
        auto srelu0 = subG->addOp<ReluObj>(si0, nullptr);
        auto sw0 = subG->addTensor({96, 96, 3, 3}, DataType::UInt32);
        auto sconv0 = subG->addOp<ConvObj>(srelu0->getOutput(0), sw0, nullptr);
        auto srelu1 = subG->addOp<ReluObj>(sconv0->getOutput(), nullptr);
        auto sw1 = subG->addTensor({96, 96, 3, 3}, DataType::UInt32);
        auto sconv1 = subG->addOp<ConvObj>(srelu1->getOutput(0), sw1, nullptr);
        auto sadd0 = subG->addOp<AddObj>(sconv1->getOutput(0),
                                         srelu0->getOutput(0), nullptr);
        subG->setOutputs({sadd0->getOutput()});
    }
    // subG1
    Tensor si00 =
        make_ref<TensorObj>(Shape{1, 48, 56, 56}, DataType::UInt32, runtime);
    SubGraph subG1 = make_ref<SubGraphObj>(runtime, TensorVec{si00});
    {
        auto srelu0 = subG1->addOp<ReluObj>(si00, nullptr);
        auto sw0 = subG1->addTensor({48, 48, 3, 3}, DataType::UInt32);
        auto sconv0 = subG1->addOp<ConvObj>(srelu0->getOutput(0), sw0, nullptr);
        auto srelu1 = subG1->addOp<ReluObj>(sconv0->getOutput(), nullptr);
        auto sw1 = subG1->addTensor({48, 48, 3, 3}, DataType::UInt32);
        auto sconv1 = subG1->addOp<ConvObj>(srelu1->getOutput(0), sw1, nullptr);
        auto sadd0 = subG1->addOp<AddObj>(sconv1->getOutput(0),
                                          srelu0->getOutput(0), nullptr);
        subG1->setOutputs({sadd0->getOutput()});
    }

    // graph
    Graph g = make_ref<GraphObj>(runtime);
    SubGraphRewriter v(g);

    Tensor i0 = g->addTensor({1, 256, 56, 56}, DataType::UInt32);
    auto relu0 = g->addOp<ReluObj>(i0, nullptr);

    Tensor w0 = g->addTensor({96, 256, 3, 3}, DataType::UInt32);
    auto conv0 =
        g->addOp<ConvObj>(relu0->getOutput(0), w0, nullptr, 1, 1, 2, 2);

    auto o0 = v.addSubGraph(subG, {conv0->getOutput(0)});
    auto o1 = v.addSubGraph(subG, o0);
    auto o2 = v.addSubGraph(subG, o1);
    auto o3 = v.addSubGraph(subG, o2);
    auto relu4 = g->addOp<ReluObj>(o3[0], nullptr);

    Tensor w10 = g->addTensor({48, 256, 3, 3}, DataType::UInt32);
    auto conv10 = g->addOp<ConvObj>(relu0->getOutput(0), w10, nullptr);
    auto o10 = v.addSubGraph(subG1, {conv10->getOutput(0)});
    auto o11 = v.addSubGraph(subG1, o10);
    auto o12 = v.addSubGraph(subG1, o11);
    auto o13 = v.addSubGraph(subG1, o12);
    auto relu10 = g->addOp<ReluObj>(o13[0], nullptr);
    Tensor w1 = g->addTensor({96, 48, 3, 3}, DataType::UInt32);
    auto conv1 =
        g->addOp<ConvObj>(relu10->getOutput(), w1, nullptr, 1, 1, 2, 2);
    auto add1 =
        g->addOp<AddObj>(relu4->getOutput(), conv1->getOutput(), nullptr);

    auto o4 = v.addSubGraph(subG, TensorVec{add1->getOutput(0)});

    EXPECT_EQ(g->getOperators().size(), 52u);
    vector<MatchGraph> subgs = v.findMatch(subG);
    EXPECT_TRUE(subgs.size() == 5u);

    vector<MatchGraph> subgs1 = v.findMatch(subG1);
    EXPECT_TRUE(subgs1.size() == 4u);

    // test replace
    Tensor sii0 =
        make_ref<TensorObj>(Shape{1, 96, 28, 28}, DataType::UInt32, runtime);
    SubGraph subG2 = make_ref<SubGraphObj>(runtime, TensorVec{sii0});
    {
        auto srelu0 = subG2->addOp<ReluObj>(sii0, nullptr);
        auto sw0 = subG2->addTensor({96, 96, 3, 3}, DataType::UInt32);
        auto sconv0 = subG2->addOp<ConvObj>(srelu0->getOutput(0), sw0, nullptr);
        subG2->setOutputs(sconv0->getOutputs());
    }

    v.replaceSubGraph(subG, subG2);
    EXPECT_EQ(g->getOperators().size(), 37u);
}

TEST(MatchGraph, multi_input) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    // subG0
    Tensor i0 =
        make_ref<TensorObj>(Shape{3, 4, 5, 2}, DataType::UInt32, runtime);
    Tensor i1 = make_ref<TensorObj>(Shape{3, 4, 5}, DataType::UInt32, runtime);
    SubGraph subG = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto reduce0 =
            subG->addOp<ReduceMeanObj>(i0, nullptr, vector<int>{3}, false);
        auto sub0 = subG->addOp<SubObj>(reduce0->getOutput(0), i1, nullptr);
        subG->setOutputs(sub0->getOutputs());
    }

    SubGraph replaceG = make_ref<SubGraphObj>(
        runtime, TensorVec{i0->clone(runtime), i1->clone(runtime)});
    {
        auto reduce0 =
            replaceG->addOp<ReduceMeanObj>(replaceG->getInputsFromOutside()[0],
                                           nullptr, vector<int>{3}, false);
        auto sub0 = replaceG->addOp<AddObj>(reduce0->getOutput(0),
                                            replaceG->getInputsFromOutside()[1],
                                            nullptr);
        replaceG->setOutputs(sub0->getOutputs());
    }

    Graph g = make_ref<GraphObj>(runtime);
    SubGraphRewriter v(g);
    {
        Tensor i0 = g->addTensor({3, 4, 5, 2}, DataType::UInt32);
        Tensor i1 = g->addTensor({3, 4, 5, 2}, DataType::UInt32);
        auto add0 = g->addOp<AddObj>(i0, i1, nullptr);
        auto relu0 = g->addOp<ReluObj>(add0->getOutput(), nullptr);
        auto reduce0 = g->addOp<ReduceMeanObj>(relu0->getOutput(), nullptr,
                                               vector<int>{3}, false);
        auto o0 =
            v.addSubGraph(subG, {add0->getOutput(), reduce0->getOutput()});

        Tensor i2 = g->addTensor({3, 4, 5}, DataType::UInt32);
        auto pow0 = g->addOp<PowObj>(o0[0], i2, nullptr);

        Tensor i3 = g->addTensor({3, 4, 5, 2}, DataType::UInt32);
        auto reduce1 =
            g->addOp<ReduceMeanObj>(i3, nullptr, vector<int>{3}, false);
        auto sub0 = g->addOp<SubObj>(reduce1->getOutput(0), pow0->getOutput(0),
                                     nullptr);

        auto matches = v.findMatch(subG);
        EXPECT_EQ(2u, matches.size());

        auto div0 = g->addOp<DivObj>(reduce1->getOutput(0), i2, nullptr);
        auto add1 =
            g->addOp<AddObj>(sub0->getOutput(), div0->getOutput(), nullptr);
        matches = v.findMatch(subG);
        EXPECT_EQ(1u, matches.size());

        // two matched subgraphs overlaped,so only replaced one sub graph
        v.replaceSubGraph(subG, replaceG);
        EXPECT_EQ(1u, v.findMatch(replaceG).size());
    }
}

TEST(MatchGraph, multi_output) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    // subg0
    Tensor i =
        make_ref<TensorObj>(Shape{1, 192, 71, 71}, DataType::UInt32, runtime);
    SubGraph subg0 = make_ref<SubGraphObj>(runtime, TensorVec{i});
    {
        auto maxpool =
            subg0->addOp<MaxPoolObj>(i, nullptr, 3, 3, 0, 0, 0, 0, 2, 2);
        Tensor w0 = subg0->addTensor(Shape{64, 192, 1, 1}, DataType::UInt32);
        auto conv0 = subg0->addOp<ConvObj>(maxpool->getOutput(0), w0, nullptr);
        auto relu0 = subg0->addOp<ReluObj>(conv0->getOutput(0), nullptr);

        auto pad = subg0->addOp<PadObj>(maxpool->getOutput(0), nullptr,
                                        vector<int>{0, 0, 1, 1, 0, 0, 1, 1},
                                        std::nullopt);
        auto avgpool = subg0->addOp<AvgPoolObj>(pad->getOutput(0), nullptr, 3,
                                                3, 0, 0, 0, 0, 1, 1);
        subg0->setOutputs(
            TensorVec{relu0->getOutput(0), avgpool->getOutput(0)});
    }

    SubGraph subg1 =
        make_ref<SubGraphObj>(runtime, TensorVec{i->clone(runtime)});
    {
        auto avgpool = subg1->addOp<AvgPoolObj>(
            subg1->getInputsFromOutside()[0], nullptr, 3, 3, 0, 0, 0, 0, 2, 2);

        auto relu0 = subg1->addOp<ReluObj>(avgpool->getOutput(0), nullptr);

        auto split0 =
            subg1->addOp<SplitObj>(avgpool->getOutput(0), std::nullopt, 1, 3);
        subg1->setOutputs(TensorVec{split0->getOutput(1), relu0->getOutput(0)});
    }

    Graph g = make_ref<GraphObj>(runtime);
    SubGraphRewriter v(g);
    {
        auto input = g->cloneTensor(i);
        auto outs = v.addSubGraph(subg0, {input});
        EXPECT_EQ(2u, outs.size());
        Tensor w0 = g->addTensor(Shape{96, 64, 3, 3}, DataType::UInt32);
        auto conv0 = g->addOp<ConvObj>(outs[0], w0, nullptr, 1, 1);
        auto relu0 = g->addOp<ReluObj>(conv0->getOutput(0), nullptr);

        Tensor w1 = g->addTensor(Shape{96, 96, 3, 3}, DataType::UInt32);
        auto conv1 = g->addOp<ConvObj>(relu0->getOutput(), w1, nullptr, 1, 1);
        auto relu1 = g->addOp<ReluObj>(conv1->getOutput(0), nullptr);

        Tensor w2 = g->addTensor(Shape{32, 192, 1, 1}, DataType::UInt32);
        auto conv2 = g->addOp<ConvObj>(outs[1], w2, nullptr);
        auto relu2 = g->addOp<ReluObj>(conv2->getOutput(0), nullptr);

        Tensor i0 = g->addTensor(Shape{1, 64, 35, 35}, DataType::UInt32);
        Tensor i1 = g->addTensor(Shape{1, 64, 35, 35}, DataType::UInt32);
        auto concat = g->addOp<ConcatObj>(
            TensorVec{i0, i1, relu1->getOutput(), relu2->getOutput()}, nullptr,
            1);
        auto o = concat->getOutput();
        EXPECT_TRUE((o->getDims() == Shape{1, 256, 35, 35}));
    }

    auto matches = v.findMatch(subg0);
    EXPECT_EQ(1u, matches.size());

    v.replaceSubGraph(subg0, subg1);
    auto matches2 = v.findMatch(subg1);
    EXPECT_EQ(1u, matches2.size());
}

// gcn
TEST(MatchGraph, multi_input_output) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    // subg0
    Tensor i0 =
        make_ref<TensorObj>(Shape{1, 64, 112, 112}, DataType::UInt32, runtime);
    Tensor i1 =
        make_ref<TensorObj>(Shape{1, 64, 56, 56}, DataType::UInt32, runtime);
    SubGraph subg0 = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto slice = subg0->addOp<SliceObj>(i0, nullptr, vector<int>{0, 0},
                                            vector<int>{56, 56},
                                            vector<int>{2, 3}, std::nullopt);
        auto relu0 = subg0->addOp<ReluObj>(slice->getOutput(0), nullptr);
        Tensor w0 = subg0->addTensor(Shape{256, 64, 1, 1}, DataType::UInt32);
        auto conv0 = subg0->addOp<ConvObj>(relu0->getOutput(0), w0, nullptr);

        auto conv1 = subg0->addOp<ConvObj>(i1, w0, nullptr);
        auto add = subg0->addOp<AddObj>(conv0->getOutput(0),
                                        conv1->getOutput(0), nullptr);

        auto relu1 = subg0->addOp<ReluObj>(add->getOutput(0), nullptr);
        Tensor w2 = subg0->addTensor(Shape{128, 256, 1, 1}, DataType::UInt32);
        auto conv2 = subg0->addOp<ConvObj>(relu1->getOutput(0), w2, nullptr);
        auto maxpool = subg0->addOp<MaxPoolObj>(relu1->getOutput(0), nullptr, 3,
                                                3, 0, 0, 0, 0, 2, 2);
        subg0->setOutputs(
            TensorVec{conv2->getOutput(0), maxpool->getOutput(0)});
    }

    SubGraph subg1 = make_ref<SubGraphObj>(runtime, TensorVec{i1, i0});
    {
        auto slice = subg1->addOp<SliceObj>(i0, nullptr, vector<int>{0, 0},
                                            vector<int>{56, 56},
                                            vector<int>{2, 3}, std::nullopt);
        auto relu0 = subg1->addOp<ReluObj>(slice->getOutput(0), nullptr);
        Tensor w0 = subg1->addTensor(Shape{256, 64, 1, 1}, DataType::UInt32);
        auto conv0 = subg1->addOp<ConvObj>(relu0->getOutput(0), w0, nullptr);

        auto conv1 = subg1->addOp<ConvObj>(i1, w0, nullptr);
        auto add = subg1->addOp<AddObj>(conv1->getOutput(0),
                                        conv0->getOutput(0), nullptr);

        auto relu1 = subg1->addOp<ReluObj>(add->getOutput(0), nullptr);
        Tensor w2 = subg1->addTensor(Shape{128, 256, 1, 1}, DataType::UInt32);
        auto conv2 = subg1->addOp<ConvObj>(relu1->getOutput(0), w2, nullptr);
        auto maxpool = subg1->addOp<MaxPoolObj>(relu1->getOutput(0), nullptr, 3,
                                                3, 0, 0, 0, 0, 2, 2);
        subg1->setOutputs(
            TensorVec{maxpool->getOutput(0), conv2->getOutput(0)});
    }

    SubGraph subg2 = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto extend = subg2->addOp<ExtendObj>(i0, nullptr, 1, 3);

        auto slice = subg2->addOp<SliceObj>(
            extend->getOutput(0), nullptr, vector<int>{0, 0},
            vector<int>{56, 56}, vector<int>{2, 3}, std::nullopt);

        auto extend1 = subg2->addOp<ExtendObj>(i1, nullptr, 1, 3);
        auto add = subg2->addOp<AddObj>(extend1->getOutput(0),
                                        slice->getOutput(0), nullptr);

        auto relu1 = subg2->addOp<ReluObj>(add->getOutput(0), nullptr);
        Tensor w2 = subg2->addTensor(Shape{128, 256, 1, 1}, DataType::UInt32);
        auto conv2 = subg2->addOp<ConvObj>(relu1->getOutput(0), w2, nullptr);
        auto avgpool = subg2->addOp<AvgPoolObj>(relu1->getOutput(0), nullptr, 3,
                                                3, 0, 0, 0, 0, 2, 2);
        subg2->setOutputs(
            TensorVec{conv2->getOutput(0), avgpool->getOutput(0)});
    }

    Graph g = make_ref<GraphObj>(runtime);
    SubGraphRewriter v(g);
    {
        auto i = g->addTensor(Shape{1, 64, 112, 112}, DataType::UInt32);
        auto relu = g->addOp<ReluObj>(i, nullptr);
        auto maxPool = g->addOp<MaxPoolObj>(relu->getOutput(0), nullptr, 3, 3,
                                            0, 0, 1, 1, 2, 2);
        auto out0 =
            v.addSubGraph(subg0, {relu->getOutput(0), maxPool->getOutput(0)});
        auto out1 =
            v.addSubGraph(subg1, {maxPool->getOutput(0), relu->getOutput(0)});
        EXPECT_EQ(2u, out0.size());
        EXPECT_EQ(2u, out1.size());
        auto div = g->addOp<DivObj>(out0[0], out1[1], nullptr);
        auto sub = g->addOp<SubObj>(out0[1], out1[0], nullptr);
    }

    EXPECT_EQ(2u, v.findMatch(subg0).size());
    EXPECT_EQ(2u, v.findMatch(subg1).size());
    v.replaceSubGraph(subg0, subg2);
    EXPECT_EQ(v.findMatch(subg2).size(), 2u);
}

/* One Node having two or more successors is not supported yet.
TEST(MatchGraph, same_successor) {
    Runtime runtime = NativeCpuRuntimeObj::getInstance();
    // subg0
    Tensor i0 =
        make_ref<TensorObj>(Shape{1, 64, 112, 112}, DataType::UInt32, runtime);
    Tensor i1 =
        make_ref<TensorObj>(Shape{1, 64, 112, 112}, DataType::UInt32, runtime);
    SubGraph subg0 = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto add0 = subg0->addOp<AddObj>(i0, i1, nullptr);
        auto add1 = subg0->addOp<AddObj>(add0->getOutput(0), i1, nullptr);
        auto add2 = subg0->addOp<AddObj>(add0->getOutput(0), i1, nullptr);

        auto mul = subg0->addOp<MulObj>(add1->getOutput(0), i1, nullptr);
        auto div = subg0->addOp<DivObj>(add2->getOutput(0), i1, nullptr);

        auto sub =
            subg0->addOp<SubObj>(mul->getOutput(0), div->getOutput(0), nullptr);

        subg0->setOutputs(TensorVec{sub->getOutput(0)});
    }

    // pattern
    SubGraph pattern1 = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto add0 = pattern1->addOp<AddObj>(i0, i1, nullptr);
        auto add1 = pattern1->addOp<AddObj>(add0->getOutput(0), i1, nullptr);
        auto div = pattern1->addOp<DivObj>(add1->getOutput(0), i1, nullptr);
        pattern1->setOutputs(TensorVec{add0->getOutput(0), div->getOutput(0)});
    }

    // pattern
    SubGraph pattern2 = make_ref<SubGraphObj>(runtime, TensorVec{i0, i1});
    {
        auto add0 = pattern2->addOp<AddObj>(i0, i1, nullptr);
        auto add1 = pattern2->addOp<AddObj>(add0->getOutput(0), i1, nullptr);
        pattern2->setOutputs(TensorVec{add0->getOutput(0), add1->getOutput(0)});
    }

    Graph g = make_ref<GraphObj>(runtime);
    SubGraphRewriter v(g);
    {
        i0 = g->addTensor(Shape{1, 64, 112, 112}, DataType::UInt32);
        i1 = g->addTensor(Shape{1, 64, 112, 112}, DataType::UInt32);
        auto out0 = v.addSubGraph(subg0, {i0, i1});
    }

    EXPECT_EQ(1, v.findMatch(pattern1).size());
    EXPECT_EQ(2, v.findMatch(pattern2).size());
    v.replaceSubGraph(pattern2, pattern1);
    EXPECT_EQ(v.findMatch(pattern2).size(), 2);
}*/
} // namespace infini