Dumb meme

package me.genericskid.challenge;

import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;

import me.genericskid.challenge.Driver.Drawer.DrawBuilder;
import me.genericskid.challenge.Driver.Formatter.FormatterBuilder;
import me.genericskid.challenge.Driver.Template.TemplateBuilder;

public class Driver {
    public static void main(String[] args) {
        long dxTime = System.currentTimeMillis();
        Logger logger = Logger.getLogger("DrawTask");
        try {
            logger.info("Setting up factories");
            Factories.setup();
            logger.info("Creating Drawer-Factory");
            Drawer.Factory factory = Factories.getFactory(Drawer.class);
            Drawer.DrawBuilder builder = factory.create();
            builder.setDrawSize(7);
            builder.setDrawChar("T");
            builder.setWhitespaceChar(" ");
            logger.info("Creating Drawer");
            try(Drawer draw = builder.build()) {
                logger.info("Running Drawer");
                draw.draw();
            } finally {
                dxTime = System.currentTimeMillis() - dxTime;
                logger.info("Drawer finished task & disposed, total process time: " + dxTime);
            }
        } catch (Exception e) {
            String content = null;
            // Create exception string.
            if (e.getMessage() != null) {
                content = e.getMessage();
            } else if (e.getCause() != null){
                if (e.getCause().getMessage() != null) {
                    content = e.getCause().getMessage();
                } else {
                    content = e.toString();
                }
            } else {
                content = e.toString();
            }
            logger.severe("Fatal exception: " + content);
        }
    }

    /**
     * Draw utility.
     */
    static class Drawer implements AutoCloseable {
        /**
         * Delegate for creating initial strings. Output of the {@link #draw}
         * call is based off of modifications of these original strings.
         */
        private final Template template;
        /**
         * The formatter that finalizes the style of the output.
         */
        private final Formatter format;
        /**
         * Size of the drawn element.
         */
        private final int size;

        public Drawer(int size, String defaultChar, String paddingChar) {
            this.size = size * 2;
            // setup template generator
            Template.Factory factoryTemplate = Factories.getFactory(Template.class);
            Template.TemplateBuilder builderTemplate = factoryTemplate.create();
            builderTemplate.setDefaultChar(defaultChar);
            this.template = builderTemplate.build();
            // setup formatter
            Formatter.Factory factoryFormatter = Factories.getFactory(Formatter.class);
            Formatter.FormatterBuilder builderFormatter = factoryFormatter.create();
            builderFormatter.setPaddingChar(paddingChar);
            this.format = builderFormatter.build();
        }

        /**
         * Create the text-image.
         */
        public final void draw() {
            int width = size;
            for (int i = 0; i < size; i += 2) {
                String strTemplate = template.size(i + 1);
                String strFormat = format.center(strTemplate, width);
                System.out.println(strFormat);
            }
        }

        // ==================================================================================//
        // ====================                  FACTORY                   ==================//
        // ==================================================================================//

        static interface Factory extends FactoryBase<DrawBuilder> {
            DrawBuilder create();
        }

        static class DrawBuilder implements BuilderBase<Drawer> {
            private String drawChar, whiteChar;
            private int size;

            public void setDrawChar(String drawChar) { this.drawChar = drawChar; }
            public void setWhitespaceChar(String whiteChar) { this.whiteChar = whiteChar; }
            public void setDrawSize(int size) { this.size = size; }

            public Drawer build() {
                return new Drawer(size, drawChar, whiteChar);
            }
        }

        @Override
        public void close() throws Exception {
            System.out.close();
        }
    }

    /**
     * String generator with initial values.
     */
    static class Template {
        private final String def, base;

        public Template(String def) {
            this.def = def;
            StringBuilder tmpBase = new StringBuilder();
            while (tmpBase.length() < 512)
                tmpBase.append(def);
            base = tmpBase.toString();
        }

        /**
         * Create a string of the given length.
         *
         * @param len
         *            String length to create.
         * @return String of given length.
         */
        public final String size(int len) {
            return base.substring(0, len);
        }

        // ==================================================================================//
        // ====================                  FACTORY                   ==================//
        // ==================================================================================//

        static interface Factory extends FactoryBase<TemplateBuilder> {
            TemplateBuilder create();
        }

        static class TemplateBuilder implements BuilderBase<Template> {
            private String defaultChar;

            public void setDefaultChar(String defaultChar) { this.defaultChar = defaultChar; }

            public Template build() {
                return new Template(defaultChar);
            }
        }
    }

    /**
     * String formatter.
     */
    static class Formatter {
        private final String paddingChar;

        Formatter(String paddingChar) {
            this.paddingChar = paddingChar;
        }

        public String center(String s, int size) {
            StringBuilder sb = new StringBuilder(size);
            for (int i = 0; i < (size - s.length()) / 2; i++)
                sb.append(paddingChar);
            sb.append(s);
            while (sb.length() < size)
                sb.append(paddingChar);
            return sb.toString();
        }

        // ==================================================================================//
        // ====================                  FACTORY                   ==================//
        // ==================================================================================//

        static interface Factory extends FactoryBase<FormatterBuilder> {
            FormatterBuilder create();
        }

        static class FormatterBuilder implements BuilderBase<Formatter> {
            private String paddingChar;

            public void setPaddingChar(String paddingChar) { this.paddingChar = paddingChar; }

            public Formatter build() {
                return new Formatter(paddingChar);
            }
        }
    }

    /**
     * Factory instance handler.
     */
    static class Factories {
        @SuppressWarnings("rawtypes")
        private static final Map<Class, FactoryBase> factories = new HashMap<>();

        public static void setup() {
            factories.put(Drawer.class, new Drawer.Factory() {
                @Override
                public DrawBuilder create() {
                    return new DrawBuilder();
                }
            });
            factories.put(Template.class, new Template.Factory() {
                @Override
                public TemplateBuilder create() {
                    return new TemplateBuilder();
                }
            });
            factories.put(Formatter.class, new Formatter.Factory() {
                @Override
                public FormatterBuilder create() {
                    return new FormatterBuilder();
                }
            });
        }

        /**
         * @param host
         *            Type of class that the factory is associated with.
         * @return Factory associated with the given host-class.
         */
        @SuppressWarnings("unchecked")
        public static <T extends FactoryBase<?>> T getFactory(Class<?> host) {
            return (T) factories.get(host);
        }
    }

    /**
     * Factory outline.
     *
     * @param <T>
     *            Type of object to be generated by the Factory.
     */
    interface FactoryBase<T> {
        T create();
    }

    /**
     * Builder outline.
     *
     * @param <T>
     *            Type of object to be generated by the factory.
     */
    interface BuilderBase<T> {
        T build();
    }
}