import {
    isMetricsTraceSupplier,
    type ITrace,
    type ITraceable,
    type ITraceWith,
    LogLevel,
    LogTrace,
    type LogTraceSupplier,
    MetricsTrace,
    type MetricsTraceSupplier,
    type MetricValue,
    TraceableImpl,
} from './index.js';

export class LogTraceable<T> extends TraceableImpl<T, LogTraceSupplier> {
    public static LogTrace = new LogTrace();
    static of<T>(t: T) {
        return new LogTraceable(t, LogTraceable.LogTrace);
    }
}

const getEmbeddedMetricConsumer = (logTrace: ITrace<LogTraceSupplier>) => (metrics: Array<MetricValue>) => {
    if (metrics.length === 0) return;
    logTrace.traceScope(LogLevel.SYS).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
};

export class EmbeddedMetricsTraceable<T> extends TraceableImpl<T, MetricsTraceSupplier> {
    public static MetricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));

    static of<T>(t: T, metricsTrace = EmbeddedMetricsTraceable.MetricsTrace) {
        return new EmbeddedMetricsTraceable(t, metricsTrace);
    }
}

export type LogMetricTraceSupplier = ITraceWith<LogTraceSupplier | MetricsTraceSupplier>;
export class LogMetricTrace implements ITrace<LogMetricTraceSupplier> {
    constructor(
        private logTrace: ITrace<LogTraceSupplier>,
        private metricsTrace: ITrace<MetricsTraceSupplier>,
    ) {}

    public traceScope(trace: LogTraceSupplier | MetricsTraceSupplier): LogMetricTrace {
        if (isMetricsTraceSupplier(trace)) {
            this.metricsTrace = this.metricsTrace.traceScope(trace);
            return this;
        }
        this.logTrace = this.logTrace.traceScope(trace);
        return this;
    }

    public trace(trace: LogTraceSupplier | MetricsTraceSupplier) {
        if (isMetricsTraceSupplier(trace)) {
            this.metricsTrace.trace(trace);
            return this;
        }
        this.logTrace.trace(trace);
        return this;
    }
}

export class LogMetricTraceable<T> extends TraceableImpl<T, MetricsTraceSupplier | LogTraceSupplier> {
    static ofLogTraceable<T>(t: ITraceable<T, LogTraceSupplier>) {
        const metricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(t.trace));
        return new LogMetricTraceable(t.get(), new LogMetricTrace(t.trace, metricsTrace));
    }

    static of<T>(t: T) {
        const logTrace = LogTraceable.of(t);
        return LogMetricTraceable.ofLogTraceable(logTrace);
    }
}