package logr

import (
	"bytes"
	"fmt"
	"io"
	"runtime"
	"strconv"
)

// Formatter turns a LogRec into a formatted string.
type Formatter interface {
	// IsStacktraceNeeded returns true if this formatter requires a stacktrace to be
	// generated for each LogRecord. Enabling features such as `Caller` field require
	// a stacktrace.
	IsStacktraceNeeded() bool

	// Format converts a log record to bytes. If buf is not nil then it will be
	// be filled with the formatted results, otherwise a new buffer will be allocated.
	Format(rec *LogRec, level Level, buf *bytes.Buffer) (*bytes.Buffer, error)
}

const (
	// DefTimestampFormat is the default time stamp format used by Plain formatter and others.
	DefTimestampFormat = "2006-01-02 15:04:05.000 Z07:00"

	// TimestampMillisFormat is the format for logging milliseconds UTC
	TimestampMillisFormat = "Jan _2 15:04:05.000"
)

// LimitByteSlice discards the bytes from a slice that exceeds the limit
func LimitByteSlice(b []byte, limit int) []byte {
	if limit > 0 && limit < len(b) {
		lb := make([]byte, limit, limit+3)
		copy(lb, b[:limit])
		return append(lb, []byte("...")...)
	}

	return b
}

// LimitString discards the runes from a slice that exceeds the limit
func LimitString(b string, limit int) string {
	return string(LimitByteSlice([]byte(b), limit))
}

type LimitedStringer struct {
	fmt.Stringer
	Limit int
}

func (ls *LimitedStringer) String() string {
	return LimitString(ls.Stringer.String(), ls.Limit)
}

type Writer struct {
	io.Writer
}

func (w Writer) Writes(elems ...[]byte) (int, error) {
	var count int
	for _, e := range elems {
		if c, err := w.Write(e); err != nil {
			return count + c, err
		} else {
			count += c
		}
	}
	return count, nil
}

// DefaultFormatter is the default formatter, outputting only text with
// no colors and a space delimiter. Use `format.Plain` instead.
type DefaultFormatter struct {
}

// IsStacktraceNeeded always returns false for default formatter since the
// `Caller` field is not supported.
func (p *DefaultFormatter) IsStacktraceNeeded() bool {
	return false
}

// Format converts a log record to bytes.
func (p *DefaultFormatter) Format(rec *LogRec, level Level, buf *bytes.Buffer) (*bytes.Buffer, error) {
	if buf == nil {
		buf = &bytes.Buffer{}
	}
	timestampFmt := DefTimestampFormat

	buf.WriteString(rec.Time().Format(timestampFmt))
	buf.Write(Space)

	buf.WriteString(level.Name)
	buf.Write(Space)

	buf.WriteString(rec.Msg())
	buf.Write(Space)

	fields := rec.Fields()
	if len(fields) > 0 {
		if err := WriteFields(buf, fields, Space, NoColor); err != nil {
			return nil, err
		}
	}

	if level.Stacktrace {
		frames := rec.StackFrames()
		if len(frames) > 0 {
			buf.Write(Newline)
			if err := WriteStacktrace(buf, rec.StackFrames()); err != nil {
				return nil, err
			}
		}
	}
	buf.Write(Newline)

	return buf, nil
}

// WriteFields writes zero or more name value pairs to the io.Writer.
// The pairs output in key=value format with optional separator between fields.
func WriteFields(w io.Writer, fields []Field, separator []byte, color Color) error {
	ws := Writer{w}

	sep := []byte{}
	for _, field := range fields {
		if err := writeField(ws, field, sep, color); err != nil {
			return err
		}
		sep = separator
	}
	return nil
}

func writeField(ws Writer, field Field, sep []byte, color Color) error {
	if len(sep) != 0 {
		if _, err := ws.Write(sep); err != nil {
			return err
		}
	}
	if err := WriteWithColor(ws, field.Key, color); err != nil {
		return err
	}
	if _, err := ws.Write(Equals); err != nil {
		return err
	}
	return field.ValueString(ws, shouldQuote)
}

// shouldQuote returns true if val contains any characters that might be unsafe
// when injecting log output into an aggregator, viewer or report.
func shouldQuote(val string) bool {
	for _, c := range val {
		if !((c >= '0' && c <= '9') ||
			(c >= 'a' && c <= 'z') ||
			(c >= 'A' && c <= 'Z') ||
			c == '-' || c == '.' || c == '_' || c == '/' || c == '@' || c == '^' || c == '+') {
			return true
		}
	}
	return false
}

// WriteStacktrace formats and outputs a stack trace to an io.Writer.
func WriteStacktrace(w io.Writer, frames []runtime.Frame) error {
	ws := Writer{w}
	for _, frame := range frames {
		if frame.Function != "" {
			if _, err := ws.Writes(Space, Space, []byte(frame.Function), Newline); err != nil {
				return err
			}
		}
		if frame.File != "" {
			s := strconv.FormatInt(int64(frame.Line), 10)
			if _, err := ws.Writes([]byte{' ', ' ', ' ', ' ', ' ', ' '}, []byte(frame.File), Colon, []byte(s), Newline); err != nil {
				return err
			}
		}
	}
	return nil
}

// WriteWithColor outputs a string with the specified ANSI color.
func WriteWithColor(w io.Writer, s string, color Color) error {
	var err error

	writer := func(buf []byte) {
		if err != nil {
			return
		}
		_, err = w.Write(buf)
	}

	if color != NoColor {
		writer(AnsiColorPrefix)
		writer([]byte(strconv.FormatInt(int64(color), 10)))
		writer(AnsiColorSuffix)
	}

	if err == nil {
		_, err = io.WriteString(w, s)
	}

	if color != NoColor {
		writer(AnsiColorPrefix)
		writer([]byte(strconv.FormatInt(int64(NoColor), 10)))
		writer(AnsiColorSuffix)
	}
	return err
}