package io.trygvis.container.compiler.model;

import javax.lang.model.type.TypeMirror;
import java.io.CharArrayWriter;
import java.io.PrintWriter;
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;
    private 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<>();

//    public ClassG(String packageName, String className) {
//        this(packageName, className, null);
//    }

    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(type, name);
        fields.add(ref);
        return ref;
    }

    public MethodRef addMethod(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) {
        writer.println("package " + packageName + ";");
        writer.println();
        for (TypeRef i : imports) {
            if (i.isPrimitive()) {
                continue;
            }
            writer.println("import " + i.canonicalName() + ";");
        }
        writer.println();
        writer.println("public class " + className + " extends " + extendsClass + " {");
        for (FieldRef field : fields) {
            writer.println("    private final " + field.klass.name + " " + field.name + ";");
        }

        for (MethodRef method : methods) {
            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(p.klass.name + " " + p.name);
        }

        writer.println("    public " + returnString + " " + method.name + "(" + collectionToDelimitedString(parameters, ", ") + ") {");
        writer.println(method.body);
        writer.println("    }");
    }

    public void simpleConstructor(List<ParameterRef> parameters, List<String> goesToSuper) {
        List<String> ps = new ArrayList<>();
        for (ParameterRef p : parameters) {
            ps.add(p.klass.name + " " + p.name);
        }
        List<String> ss = new ArrayList<>();
        List<String> local = new ArrayList<>();
        for (String s : goesToSuper) {
            for (ParameterRef parameter : parameters) {
                if (parameter.name.equals(s)) {
                    ss.add(parameter.name);
                    continue;
                }
            }
            local.add(s);
        }
        String params = ps.size() == 0 ? "" : ", " + collectionToDelimitedString(ps, ", ");

        CharArrayWriter buffer = new CharArrayWriter();
        PrintWriter writer = new PrintWriter(buffer);

        writer.println("    public " + className + "(" + params + ") {");
        writer.println("        super(" + collectionToDelimitedString(ss, ", ") + ");");
//        writer.println("        this.transactionManager = _transactionManager_;");
        for (String s : local) {
            writer.println("        this." + s + " = " + s);
        }
        writer.println("    }");
    }
}