package io.trygvis.container.compiler.model;

import javax.lang.model.type.TypeMirror;
import java.io.PrintWriter;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import static org.springframework.util.StringUtils.collectionToDelimitedString;

public class ClassG {
    private final String packageName;
    public final String className;
    private final String extendsClass;
    private final Set<TypeRef> imports = new TreeSet<>();
    private final Set<FieldRef> fields = new TreeSet<>();
    private final List<MethodRef> methods = new ArrayList<>();
    private final List<Constructor> constructors = new ArrayList<>();

    public ClassG(String packageName, String className, String extendsClass) {
        this.packageName = packageName;
        this.className = className;
        this.extendsClass = extendsClass;
    }

    public TypeRef addImport(final TypeMirror type) {
        if (type.getKind().isPrimitive()) {
            return TypeRef.find(type.getKind());
        }

        String canonicalName = type.toString();
        System.out.println("canonicalName = " + canonicalName);

        for (TypeRef i : imports) {
            if (i.canonicalName().equals(canonicalName)) {
                return i;
            }
        }

        TypeRef ref = new TypeRef(canonicalName, canonicalName);
        imports.add(ref);
        return ref;
    }

    public TypeRef addImport(Class<?> klass) {
//        if (klass.isPrimitive()) {
//            return TypeRef.PRIMITIVE;
//        }

        String canonicalName = klass.getCanonicalName();
        String simpleName = klass.getSimpleName();
        String name = simpleName;
        for (TypeRef i : imports) {
            if (i.canonicalName().equals(canonicalName)) {
                return i;
            }

            if (i.name.equals(simpleName)) {
                name = canonicalName;
                break;
            }
        }

        TypeRef ref = new TypeRef(name, canonicalName);
        imports.add(ref);

        return ref;
    }

    public FieldRef addField(Class<?> klass, String name) {
        TypeRef type = addImport(klass);
        FieldRef ref = new FieldRef(Modifier.PRIVATE | Modifier.FINAL, type, name);
        fields.add(ref);
        return ref;
    }

    public FieldRef addPublicFinalField(Class<?> klass, String name) {
        TypeRef type = addImport(klass);
        FieldRef ref = new FieldRef(Modifier.PUBLIC | Modifier.FINAL, type, name);
        fields.add(ref);
        return ref;
    }

    public Constructor addConstructor(Parameters parameters, List<String> body) {
        Constructor constructor = new Constructor(this, parameters, body);
        constructors.add(constructor);
        return constructor;
    }

    public MethodRef addMethod(List<String> body, TypeRef returnType, String name, ParameterRef... parameters) {
        MethodRef ref = new MethodRef(returnType, name, parameters, body);
        methods.add(ref);
        return ref;
    }

    public void write(PrintWriter writer) {
        if(packageName.length() > 0) {
            writer.println("package " + packageName + ";");
            writer.println();
        }
        for (TypeRef i : imports) {
            if (i.isPrimitive()) {
                continue;
            }
            writer.println("import " + i.canonicalName() + ";");
        }
        writer.println();

        String extendsString = extendsClass == null ? "" : " extends " + extendsClass;

        writer.println("public class " + className + extendsString + " {");
        for (FieldRef field : fields) {
            writer.println();
            writer.println("    " + field.toJava() + ";");
        }

        for (Constructor constructor : constructors) {
            writer.println();
            for (String s : constructor.write()) {
                writer.println(s);
            }
        }

        for (MethodRef method : methods) {
            writer.println();
            write(writer, method);
        }

        writer.println("}");
    }

    private void write(PrintWriter writer, MethodRef method) {
        String returnString;
        if (method.returnType == TypeRef.VOID) {
            returnString = "void";
        } else {
            returnString = method.returnType.name;
        }

        List<String> parameters = new ArrayList<>();
        for (ParameterRef p : method.parameters) {
            parameters.add("final " + p.klass.name + " " + p.name);
        }

        writer.println("    public " + returnString + " " + method.name + "(" + collectionToDelimitedString(parameters, ", ") + ") {");
        for (String s : method.body) {
            writer.print("        ");
            writer.println(s);
        }
        writer.println("    }");
    }
}