package io.jstach.opt.spring.example.hello;

/**
 * Generated Renderer.
 */
// @javax.annotation.Generated("io.jstach.apt.GenerateRendererProcessor")
@org.springframework.stereotype.Component
public class HelloModelView implements io.jstach.jstachio.Template<io.jstach.opt.spring.example.hello.HelloModel>,
    io.jstach.jstachio.TemplateInfo,
    io.jstach.jstachio.spi.TemplateProvider,
    io.jstach.jstachio.spi.JStachioFilter.FilterChain {
    /**
     * Template path.
     * @hidden
     */
    public static final String TEMPLATE_PATH = "views/hello.mustache";

    /**
     * Inline template string copied.
     * @hidden
     */

    public static final String TEMPLATE_STRING = "";

    /**
     * Template name. Do not rely on this.
     * @hidden
     */
    public static final String TEMPLATE_NAME = "io.jstach.opt.spring.example.hello.HelloModelView";

    /**
     * The models class. Use {@link #modelClass()} instead.
     * @hidden
     */
    public static final Class<?> MODEL_CLASS = io.jstach.opt.spring.example.hello.HelloModel.class;

    /**
     * The instance. Use {@link {@link #of()} instead.
     * @hidden
     */
    private static final HelloModelView INSTANCE = new HelloModelView();

    /**
     * Formatter. 
     * @hidden
     */
    private final io.jstach.jstachio.Formatter formatter;

    /**
     * Escaper. 
     * @hidden
     */
    private final io.jstach.jstachio.Escaper escaper;

    /**
     * Renderer constructor for manual wiring.
     * @param formatter formatter if null the static formatter will be used.
     * @param escaper escaper if null the static escaper will be used
     */
    public HelloModelView(
        /* @Nullable */ java.util.function.Function< /* @Nullable */ Object, String> formatter,
        /* @Nullable */ java.util.function.Function<String, String> escaper) {
        super();
        this.formatter = __formatter(formatter);
        this.escaper = __escaper(escaper);
    }

    private static io.jstach.jstachio.Formatter __formatter(/* @Nullable */ java.util.function.Function< /* @Nullable */ Object, String> formatter) {
        return io.jstach.jstachio.Formatter.of(formatter != null ? formatter : io.jstach.jstachio.formatters.DefaultFormatter.provider());
    }

    private static io.jstach.jstachio.Escaper __escaper(/* @Nullable */ java.util.function.Function<String, String> escaper) {
        return io.jstach.jstachio.Escaper.of(escaper != null ? escaper : io.jstach.jstachio.escapers.Html.provider());
    }

    /**
     * Renderer constructor for reflection (use of() instead).
     * For programmatic consider using {@link #of()} for a shared singleton.
     */
    public HelloModelView() {
        this(null, null);
    }

    @Override
    public void execute(io.jstach.opt.spring.example.hello.HelloModel model, Appendable a) throws java.io.IOException {
        execute(model, a, templateFormatter(), templateEscaper());
    }

    @Override
    public void execute(
        io.jstach.opt.spring.example.hello.HelloModel model, 
        java.lang.Appendable a, 
        io.jstach.jstachio.Formatter formatter,
        io.jstach.jstachio.Escaper escaper) throws java.io.IOException {
        render(model, a, formatter, escaper, templateAppender());
    }

    @Override
    public boolean supportsType(Class<?> type) {
        return MODEL_CLASS.isAssignableFrom(type);
    }

    /**
     * Needed for jstachio runtime.
     * @hidden
     */
    @Override
    public java.util.List<io.jstach.jstachio.Template<?>> provideTemplates(io.jstach.jstachio.TemplateConfig templateConfig ) {
        return java.util.List.of(io.jstach.jstachio.TemplateConfig.empty() == templateConfig ? INSTANCE :  new HelloModelView(templateConfig));
    }

    @Override
    public String templatePath() {
        return TEMPLATE_PATH;
    }
    @Override
    public String templateName() {
        return TEMPLATE_NAME;
    }
    @Override
    public String templateString() {
        return TEMPLATE_STRING;
    }
    @Override
    public Class<?> templateContentType() {
        return io.jstach.jstachio.escapers.Html.class;
    }
    @Override
    public  io.jstach.jstachio.Escaper templateEscaper() {
        return this.escaper;
    }

    @Override
    public io.jstach.jstachio.Formatter templateFormatter() {
        return this.formatter;
    }

    /**
     * Appender.
     * @return appender for writing unescaped variables.
     */
    public io.jstach.jstachio.Appender<java.lang.Appendable> templateAppender() {
        return io.jstach.jstachio.Appender.defaultAppender();
    }

    /**
     * Model class.
     * @return class used as model (annotated with JStache).
     */
    @Override
    public Class<?> modelClass() {
        return MODEL_CLASS;
    }

    /**
     * Needed for jstachio runtime.
     * @hidden
     */
    @SuppressWarnings("unchecked")
    @Override
    public void process(Object model, Appendable appendable) throws java.io.IOException {
        execute( (io.jstach.opt.spring.example.hello.HelloModel) model, appendable);
    }

    /**
     * Needed for jstachio runtime.
     * @hidden
     */
    @Override
    public boolean isBroken(Object model) {
        return !supportsType(model.getClass());
    }

    /**
     * Renderer constructor using config.
     * @param templateConfig config that has collaborators
     */
    public HelloModelView(io.jstach.jstachio.TemplateConfig templateConfig) {
        this(templateConfig.formatter(), templateConfig.escaper());
    }

    /**
     * Convience static factory that will reuse the same singleton instance.
     * @return renderer same as calling no-arg constructor but is cached with singleton instance
     */
    public static HelloModelView of() {
        return INSTANCE;
    }

    /**
     * Renders the passed in model.
     * @param <A> appendable type.
     * @param data model
     * @param unescapedWriter appendable to write to.
     * @param formatter formats variables before they are passed to the escaper.
     * @param escaper used to write escaped variables.
     * @param appender used to write unescaped variables.
     * @throws java.io.IOException if an error occurs while writing to the appendable
     */
    public static <A extends java.lang.Appendable> void render(
        io.jstach.opt.spring.example.hello.HelloModel data, 
        A unescapedWriter,
        io.jstach.jstachio.Formatter formatter,
        io.jstach.jstachio.Appender<? super A> escaper,
        io.jstach.jstachio.Appender<A> appender) throws java.io.IOException {

        unescapedWriter.append(
            "<!doctype html>\n" +
            "<html lang=\"en\">\n" +
            "  <head>\n" +
            "    <meta charset=\"utf-8\">\n" +
            "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n" +
            "    <link rel=\"stylesheet\" href=\"https://unpkg.com/@picocss/pico@latest/css/pico.min.css\">\n" +
            "    <title>Hello, "); 

        // variable: message
        /* RenderingContext: class io.jstach.apt.internal.context.DeclaredTypeRenderingContext */
        /* TypeMirror: java.lang.String */
        formatter.format(escaper, unescapedWriter, "message", data.message());

        unescapedWriter.append(
            "!</title>\n" +
            "  </head>\n" +
            "  <body>\n" +
            "    <main class=\"container\">\n" +
            "      <h1>"); 

        // variable: message
        /* RenderingContext: class io.jstach.apt.internal.context.DeclaredTypeRenderingContext */
        /* TypeMirror: java.lang.String */
        formatter.format(escaper, unescapedWriter, "message", data.message());

        unescapedWriter.append(
            "</h1>\n" +
            "    </main>\n" +
            "  </body>\n" +
            "</html>"); 


    }
}