// RUN: tf-opt %s -tfl-lift-tflite-flex-ops | FileCheck %s

// CHECK-LABEL: TfAdd
func.func @TfAdd(%arg0: tensor<4xf64>, %arg1: tensor<4xf64>) -> tensor<4xf64> {
  %0 = "tfl.custom"(%arg0, %arg1) {
    custom_code = "FlexAdd",
    custom_option = #tfl<const_bytes : "0x03416464001412034164641A001A002A070A015412023002320000021B171414042801">
  } : (tensor<4xf64>, tensor<4xf64>) -> tensor<4xf64>

    private final List<CustomModel> projects;

    public Models(boolean runsInParallel, Collection<CustomModel> projects) {
        this.runsInParallel = runsInParallel;
        this.projects = new ArrayList<CustomModel>(projects);
    }

    public boolean isMayRunInParallel() {
        return runsInParallel;
    }

    public List<CustomModel> getProjects() {
        return projects;
    }

import org.gradle.internal.cc.impl.fixtures.CustomModel;
import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.eclipse.EclipseProject;

class ModelStreamingBuildAction implements BuildAction<CustomModel> {
    @Override
    public CustomModel execute(BuildController controller) {

        GradleBuild gradleBuild = controller.getBuildModel();
        Map<String, CustomModel> projects = new HashMap<String, CustomModel>();
        for (BasicGradleProject project : gradleBuild.getProjects()) {
            projects.put(project.getName(), controller.getModel(project, CustomModel.class));
        }
        return projects;
    }

    }
}
"""

        when:
        def model = withConnection { connection ->
            connection.model(CustomModel).get()
        }

        then:
        model.value == 'greetings'
        model.things.find { it instanceof CustomModel.Thing }
        model.thingsByName.thing instanceof CustomModel.Thing
    }

    @Ignore("work in progress")
    def "gives reasonable error message when model build fails"() {

  %0 = "tf.TensorListReserve"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*xi32>>>
  // CHECK: %0 = "tfl.custom"(%arg0, %arg1) <{custom_code = "TensorListReserve", custom_option = #tfl<const_bytes : "0x02">}> : (tensor<i32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*xi32>>>
  func.return %0 : tensor<!tf_type.variant<tensor<*xi32>>>
}

// -----

import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.eclipse.EclipseProject;

class ModelStreamingBuildAction implements BuildAction<CustomModel> {
    @Override
    public CustomModel execute(BuildController controller) {
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);
        GradleProject gradleProject = controller.getModel(GradleProject.class);

        when:
        withConnection {
            it.model(CustomModel.class).get()
        }

        then:
        UnknownModelException e = thrown()
        e.message == "No model of type 'CustomModel' is available in this build."

        and:
        failure.assertHasDescription("No builders are available to build a model of type 'org.gradle.integtests.tooling.r16.CustomModel'.")
        assertHasConfigureFailedLogging()
    }

import javax.inject.Inject

class CustomModel implements Serializable {
    String value
}
class CustomBuilder implements ToolingModelBuilder {
    boolean canBuild(String modelName) {
        return modelName == 'org.gradle.integtests.tooling.r16.CustomModel'
    }
    Object buildAll(String modelName, Project project) {
        return new CustomModel(value: project.path)
    }
}

import org.gradle.tooling.model.GradleProject;
import org.gradle.tooling.model.eclipse.EclipseProject;

class FetchCustomModel implements BuildAction<CustomModel> {
    public CustomModel execute(BuildController controller) {
        CustomModel model = new CustomModel();
        model.gradle = controller.getModel(GradleProject.class);
        model.eclipse = controller.getModel(EclipseProject.class);
        return model;
    }