package main

import (
	"go/ast"
	"go/token"
	"reflect"
	"strings"
)

func init() {
	register(cftypeFix)
}

var cftypeFix = fix{
	name:     "cftype",
	date:     "2017-09-27",
	f:        cftypefix,
	desc:     `Fixes initializers and casts of C.*Ref and JNI types`,
	disabled: false,
}

// Old state:
//
//	type CFTypeRef unsafe.Pointer
//

  rm -f ${tmp_png_prefix}*png
elif [[ x"${cmd_type}" = "ximage" ]] ; then
  check_command convert
  target_file=$(echo "$url" | sed -e "s#^file:/*#/#g")
  convert -thumbnail ${image_size} "${target_file}" "${output_file}"
elif [[ x"${cmd_type}" = "x" ]] ; then
  echo "No filetype."
  exit 1
else
  echo "Unsupported type: ${cmd_type}"
  exit 1
fi

if [[ ! -f ${output_file} ]] ; then

	}
}

type CompositionEnv struct {
	*environment.EnvSet

	MapType           *apiservercel.DeclType
	CompiledVariables map[string]CompilationResult
}

func (c *CompositionEnv) AddField(name string, celType *cel.Type) {
	c.MapType.Fields[name] = apiservercel.NewDeclField(name, convertCelTypeToDeclType(celType), true, nil, nil)
}

// only works correctly when the type is present in the cmd package.
func getHandlerName(f http.HandlerFunc, cmdType string) string {
	name := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()

	packageName := fmt.Sprintf("github.com/minio/minio/cmd.%s.", cmdType)
	name = strings.TrimPrefix(name, packageName)
	name = strings.TrimSuffix(name, "Handler-fm")
	name = strings.TrimSuffix(name, "-fm")

    }

    SomeType newInstance(Class<? extends SomeType> implType, Class<? extends SomeType> publicType, SomeType target) {
        def generated = generate(implType, publicType)
        return generated.newInstance(target)
    }

    Class<? extends SomeType> generate(Class<? extends SomeType> implType, Class<? extends SomeType> publicType) {
        def generated = classes[publicType]

    static <T extends LanguageSourceSet> T create(Class<T> publicType, Class<? extends BaseLanguageSourceSet> implType, String name) {
        return BaseInstanceFixtureSupport.create(publicType, LanguageSourceSetInternal, implType, name) { MutableModelNode node ->
            BaseLanguageSourceSet.create(publicType, implType, new DefaultComponentSpecIdentifier("project", name), TestUtil.objectFactory())
        }
    }

	s := Builder{
		Kind:         "Empty",
		Plural:       "Empties",
		ProtoPackage: "google.golang.org/protobuf/types/known/emptypb",
		Proto:        "google.protobuf.Empty",
	}.MustBuild()

	p, err := s.NewInstance()
	assert.NoError(t, err)
	assert.Equal(t, p, config.Spec(&emptypb.Empty{}))
}

func TestMustNewProtoInstance_Panic_Nil(t *testing.T) {
	g := NewWithT(t)
	defer func() {
		r := recover()

        public <T> T newInstance(Class<T> implType, Class<? super T> baseClass) {
            // TODO - The baseClass can be inferred from the implType, so attach the serialization constructor onto the GeneratedClass rather than parameterizing and caching here
            try {
                ClassGenerator.SerializationConstructor<?> constructor = constructorCache.get(implType, () -> classGenerator.generate(implType).getSerializationConstructor(baseClass));

        def node = createNode(publicType, implType, componentId);
        return node.asMutable(ModelType.of(publicType), new SimpleModelRuleDescriptor(componentId.getName())).getInstance()
    }

    static <T extends ComponentSpec, I extends BaseComponentSpec> MutableModelNode createNode(Class<T> publicType, Class<I> implType, ComponentSpecIdentifier componentId) {

public class BaseInstanceFixtureSupport {
    static <B, T extends B, I extends B> T create(Class<T> publicType, Class<? extends B> internalView, Class<I> implType,
                                                  String name, Closure<I> createUnmanagedInstance) {
        def node = createNode(publicType, internalView, implType, name, createUnmanagedInstance)
        return node.asMutable(ModelType.of(publicType), new SimpleModelRuleDescriptor("<get $name>")).instance
    }