package org.openautonomousconnection.luascript.hosts;

import java.util.Objects;
import java.util.Optional;

/**
 * Container for host-side services exposed to Lua.
 *
 * <p>All services are optional to allow different embedding scenarios.</p>
 */
public interface HostServices {

    /**
     * Returns an optional UI host.
     *
     * @return ui host
     */
    Optional<UiHost> ui();

    /**
     * Returns an optional DOM host.
     *
     * @return dom host
     */
    Optional<DomHost> dom();

    /**
     * Returns an optional event host.
     *
     * @return event host
     */
    Optional<EventHost> events();

    /**
     * Returns an optional resource host.
     *
     * @return resource host
     */
    Optional<ResourceHost> resources();

    /**
     * Returns an optional console host.
     *
     * @return console host
     */
    Optional<ConsoleHost> console();

    /**
     * Simple immutable implementation.
     */
    final class Default implements HostServices {
        private final UiHost ui;
        private final DomHost dom;
        private final EventHost events;
        private final ResourceHost resources;
        private final ConsoleHost console;

        /**
         * Creates a HostServices container.
         *
         * @param ui ui host
         * @param dom dom host
         * @param events event host
         * @param resources resource host
         * @param console console host
         */
        public Default(UiHost ui, DomHost dom, EventHost events, ResourceHost resources, ConsoleHost console) {
            this.ui = ui;
            this.dom = dom;
            this.events = events;
            this.resources = resources;
            this.console = console;
        }

        @Override
        public Optional<UiHost> ui() {
            return Optional.ofNullable(ui);
        }

        @Override
        public Optional<DomHost> dom() {
            return Optional.ofNullable(dom);
        }

        @Override
        public Optional<EventHost> events() {
            return Optional.ofNullable(events);
        }

        @Override
        public Optional<ResourceHost> resources() {
            return Optional.ofNullable(resources);
        }

        @Override
        public Optional<ConsoleHost> console() {
            return Optional.ofNullable(console);
        }
    }

    /**
     * Stdout-based console host.
     */
    final class StdoutConsole implements ConsoleHost {
        private final String prefix;

        /**
         * Creates a new stdout console with a prefix.
         *
         * @param prefix prefix (may be empty)
         */
        public StdoutConsole(String prefix) {
            this.prefix = Objects.requireNonNull(prefix, "prefix");
        }

        @Override
        public void info(String message) {
            System.out.println(prefix + "[info] " + safe(message));
        }

        @Override
        public void log(String message) {
            System.out.println(prefix + "[log] " + safe(message));
        }

        @Override
        public void warn(String message) {
            System.out.println(prefix + "[warn] " + safe(message));
        }

        @Override
        public void error(String message) {
            System.err.println(prefix + "[error] " + safe(message));
        }

        @Override
        public void exception(String message) {
            System.err.println(prefix + "[exception] " + safe(message));
        }

        private static String safe(String s) {
            return s == null ? "" : s;
        }
    }
}