package org.jenkinsci.plugins.workflow.log;

import hudson.console.AnnotatedLargeText;
import hudson.model.BuildListener;
import hudson.model.TaskListener;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Locale;
import javax.annotation.Nonnull;
import org.jenkinsci.plugins.workflow.flow.FlowExecutionOwner;
import org.jenkinsci.plugins.workflow.graph.FlowNode;

/**
 * An implementation of {@LogStorage} that delegates all reads to a specified {@LogStorage} delegate while
 * sending writes to both the delegate and another implementation of {@link BuildListener}.
 */
public class DelegatingLogStorage implements LogStorage {

    private final LogStorage delegate;
    private final BuildListener teeListener;

    private DelegatingLogStorage(LogStorage delegate, BuildListener teeListener) {
        this.delegate = delegate;
        this.teeListener = teeListener;
    }

    @Override
    public BuildListener overallListener() throws IOException, InterruptedException {
        return new TeeBuildListener(delegate.overallListener(), teeListener);
    }

    @Override
    public TaskListener nodeListener(FlowNode node) throws IOException, InterruptedException {
        return new TeeBuildListener(delegate.nodeListener(node), teeListener);
    }

    @Override
    public AnnotatedLargeText<FlowExecutionOwner.Executable> overallLog(FlowExecutionOwner.Executable build, boolean complete) {
        return delegate.overallLog(build, complete);
    }

    @Override
    public AnnotatedLargeText<FlowNode> stepLog(FlowNode node, boolean complete) {
        return delegate.stepLog(node, complete);
    }

    @Override
    public File getLogFile(@Nonnull FlowExecutionOwner.Executable build, boolean complete) {
        return delegate.getLogFile(build, complete);
    }

    /* TODO: How should getCharset be implemented? */
    private static class TeeBuildListener implements BuildListener {
        private final PrintStream teeStream;

        public TeeBuildListener(TaskListener main, TaskListener branch) {
            teeStream = new TeePrintStream(main.getLogger(), branch.getLogger());
        }

        @Override
        public PrintStream getLogger() {
            return teeStream;
        }
    }

    private static class TeePrintStream extends PrintStream {
        private final PrintStream branch;

        public TeePrintStream(PrintStream main, PrintStream branch) {
            super(main);
            this.branch = branch;
        }

        @Override
        public boolean checkError() {
            return super.checkError() || branch.checkError();
        }

        @Override
        public PrintStream format(String format, Object... args) {
            super.format(format, args);
            branch.format(format, args);
            return this;
        }

        @Override
        public PrintStream format(Locale l, String format, Object... args) {
            super.format(l, format, args);
            branch.format(l, format, args);
            return this;
        }

        @Override
        public void print(boolean b) {
            super.print(b);
            branch.print(b);
        }

        @Override
        public void print(char c) {
            super.print(c);
            branch.print(c);
        }

        @Override
        public void print(int i) {
            super.print(i);
            branch.print(i);
        }

        @Override
        public void print(long l) {
            super.print(l);
            branch.print(l);
        }

        @Override
        public void print(float f) {
            super.print(f);
            branch.print(f);
        }

        @Override
        public void print(double d) {
            super.print(d);
            branch.print(d);
        }

        @Override
        public void print(char[] s) {
            super.print(s);
            branch.print(s);
        }

        @Override
        public void print(String s) {
            super.print(s);
            branch.print(s);
        }

        @Override
        public void print(Object o) {
            super.print(o);
            branch.print(o);
        }

        @Override
        public void println() {
            super.println();
            branch.println();
        }

        @Override
        public void println(boolean b) {
            super.println(b);
            branch.println(b);
        }

        @Override
        public void println(char c) {
            super.println(c);
            branch.println(c);
        }

        @Override
        public void println(int i) {
            super.println(i);
            branch.println(i);
        }

        @Override
        public void println(long l) {
            super.println(l);
            branch.println(l);
        }

        @Override
        public void println(float f) {
            super.println(f);
            branch.println(f);
        }

        @Override
        public void println(double d) {
            super.println(d);
            branch.println(d);
        }

        @Override
        public void println(char[] s) {
            super.println(s);
            branch.println(s);
        }

        @Override
        public void println(String s) {
            super.println(s);
            branch.println(s);
        }

        @Override
        public void println(Object o) {
            super.println(o);
            branch.println(o);
        }

        @Override
        public void write(int b) {
            super.write(b);
            branch.write(b);
        }

        @Override
        public void write(byte[] buf, int off, int length) {
            super.write(buf, off, length);
            branch.write(buf, off, length);
        }

        @Override
        public void close() {
            super.close();
            branch.close();
        }

        @Override
        public void flush() {
            super.flush();
            branch.flush();
        }
    }

}

private static class TeeBuildListener implements BuildListener {
    private final PrintStream teeStream;

    public TeeBuildListener(TaskListener main, TaskListener branch) {
        teeStream = new PrintStream(new TeeOutputStream(main.getLogger(), branch.getLogger()), false);
    }

    @Override
    public PrintStream getLogger() {
        return teeStream;
    }
}