// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package vlog

import (
	// TODO(cnicolaou): remove this dependency in the future. For now this
	// saves us some code.
	"github.com/cosmosnicolaou/llog"
)

type InfoLog interface {
	// Info logs to the INFO log.
	// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
	Info(args ...interface{})

	// Infoln logs to the INFO log.
	// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
	Infof(format string, args ...interface{})

	// InfoStack logs the current goroutine's stack if the all parameter
	// is false, or the stacks of all goroutines if it's true.
	InfoStack(all bool)
}

type Verbosity interface {
	// V returns true if the configured logging level is greater than or equal to its parameter
	V(level Level) bool
	// VI is like V, except that it returns an instance of the Info
	// interface that will either log (if level >= the configured level)
	// or discard its parameters. This allows for logger.VI(2).Info
	// style usage.
	VI(level Level) InfoLog
}

// Level specifies a level of verbosity for V logs.
// It can be set via the Level optional parameter to Configure.
// It implements the flag.Value interface to support command line option parsing.
type Level llog.Level

// Set is part of the flag.Value interface.
func (l *Level) Set(v string) error {
	return (*llog.Level)(l).Set(v)
}

// Get is part of the flag.Value interface.
func (l *Level) Get(v string) interface{} {
	return *l
}

// String is part of the flag.Value interface.
func (l *Level) String() string {
	return (*llog.Level)(l).String()
}

// StderrThreshold identifies the sort of log: info, warning etc.
// The values match the corresponding constants in C++ - e.g WARNING etc.
// It can be set via the StderrThreshold optional parameter to Configure.
// It implements the flag.Value interface to support command line option parsing.
type StderrThreshold llog.Severity

// Set is part of the flag.Value interface.
func (s *StderrThreshold) Set(v string) error {
	return (*llog.Severity)(s).Set(v)
}

// Get is part of the flag.Value interface.
func (s *StderrThreshold) Get(v string) interface{} {
	return *s
}

// String is part of the flag.Value interface.
func (s *StderrThreshold) String() string {
	return (*llog.Severity)(s).String()
}

// ModuleSpec allows for the setting of specific log levels for specific
// modules. The syntax is recordio=2,file=1,gfs*=3
// It can be set via the ModuleSpec optional parameter to Configure.
// It implements the flag.Value interface to support command line option parsing.
type ModuleSpec struct {
	llog.ModuleSpec
}

// TraceLocation specifies the location, file:N, which when encountered will
// cause logging to emit a stack trace.
// It can be set via the TraceLocation optional parameter to Configure.
// It implements the flag.Value interface to support command line option parsing.
type TraceLocation struct {
	llog.TraceLocation
}

// LevelStats tracks the number of lines of output and number of bytes
// per severity level.
type LevelStats llog.Stats

type Logger interface {
	InfoLog
	Verbosity

	// Flush flushes all pending log I/O.
	FlushLog()

	// Error logs to the ERROR and INFO logs.
	// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
	Error(args ...interface{})

	// Errorf logs to the ERROR and INFO logs.
	// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
	Errorf(format string, args ...interface{})

	// Fatal logs to the FATAL, ERROR and INFO logs,
	// including a stack trace of all running goroutines, then calls os.Exit(255).
	// Arguments are handled in the manner of fmt.Print; a newline is appended if missing.
	Fatal(args ...interface{})

	// Fatalf logs to the FATAL, ERROR and INFO logs,
	// including a stack trace of all running goroutines, then calls os.Exit(255).
	// Arguments are handled in the manner of fmt.Printf; a newline is appended if missing.
	Fatalf(format string, args ...interface{})

	// Panic is equivalent to Error() followed by a call to panic().
	Panic(args ...interface{})

	// Panicf is equivalent to Errorf() followed by a call to panic().
	Panicf(format string, args ...interface{})

	// Configure configures all future logging. Some options
	// may not be usable if Configure is called from an init function,
	// in which case an error will be returned. The Configured error is
	// returned if ConfigureLogger has already been called unless the
	// OverridePriorConfiguration options is included.
	// Some options only take effect if they are set before the logger
	// is used.  Once anything is logged using the logger, these options
	// will silently be ignored.  For example, LogDir, LogToStderr or
	// AlsoLogToStderr fall in this category.
	Configure(opts ...LoggingOpts) error

	// Stats returns stats on how many lines/bytes haven been written to
	// this set of logs per severity level.
	Stats() LevelStats

	// LogDir returns the currently configured directory for storing logs.
	LogDir() string
}

// Runtime defines the methods that the runtime must implement.
type Runtime interface {
	// Logger returns the current logger, if any, in use by the Runtime.
	// TODO(cnicolaou): remove this.
	Logger() Logger

	// NewLogger creates a new instance of the logging interface that is
	// separate from the one provided by Runtime.
	NewLogger(name string, opts ...LoggingOpts) (Logger, error)
}