// Copyright 2018 The Fuchsia 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 logger

import (
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"os"
	"runtime"
	"strings"
	"sync"
	"sync/atomic"
	"syscall/zx"

	"app/context"

	logger_fidl "fidl/fuchsia/logger"
)

var (
	ErrNotInitialized   = errors.New("default logger not initialized")
	ErrInitialized      = errors.New("default logger is already initialized")
	ErrInvalidArg       = errors.New("Invalid arguments to logger")
	ErrMsgTooLongString = "Msg too long. it was truncated"
)

// This is returned when msg is truncated. It contains the truncated part.
type ErrMsgTooLong struct {
	Msg string // rest of the message
}

func (e ErrMsgTooLong) Error() string {
	return ErrMsgTooLongString
}

const (
	MAX_GLOBAL_TAGS   = 4
	MAX_TAG_LEN       = 63
	SOCKET_BUFFER_LEN = 2032
	SOCKET_DATAGRAM   = 1 << 0
)

type LogLevel int32

const (
	InfoLevel LogLevel = iota
	WarningLevel
	ErrorLevel
	FatalLevel
)

func (ll LogLevel) String() string {
	switch ll {
	case InfoLevel:
		return "INFO"
	case WarningLevel:
		return "WARNING"
	case ErrorLevel:
		return "ERROR"
	case FatalLevel:
		return "FATAL"
	default:
		if int(ll) < 0 {
			return fmt.Sprintf("VLOG(%d)", -(int(ll)))
		}
		return "INVALID"
	}
}

type LogInitOptions struct {
	Connector         *context.Connector
	Loglevel          LogLevel
	ConsoleWriter     io.Writer
	LogServiceChannel *zx.Socket
	Tags              []string
}

func GetDefaultInitOptions() LogInitOptions {
	return LogInitOptions{
		Loglevel:          InfoLevel,
		ConsoleWriter:     nil,
		LogServiceChannel: nil,
		Tags:              nil,
	}
}

type Logger struct {
	logLevel    LogLevel
	tags        []string
	socket      *zx.Socket
	writer      atomic.Value
	tagString   string
	pid         uint64
	droppedLogs uint32
	fallbackMux sync.Mutex
}

func (l *Logger) setTags(tags []string) error {
	if len(tags) > MAX_GLOBAL_TAGS {
		return ErrInvalidArg
	}
	for _, tag := range tags {
		if len(tag) > MAX_TAG_LEN {
			return ErrInvalidArg
		}
	}
	if l.writer.Load() != nil {
		l.tagString = strings.Join(tags, ", ")
	}
	l.tags = tags
	return nil
}

func (l *Logger) ActivateFallbackMode() {
	l.fallbackMux.Lock()
	defer l.fallbackMux.Unlock()
	if l.writer.Load() != nil {
		return //already active
	}
	if l.tagString == "" {
		l.tagString = strings.Join(l.tags, ", ")
	}
	l.writer.Store(os.Stderr)
}

func connectToLogger(c *context.Connector) (*zx.Socket, error) {
	sin, sout, err := zx.NewSocket(SOCKET_DATAGRAM)
	if err != nil {
		return nil, err
	}
	req, ls, err := logger_fidl.NewLogSinkInterfaceRequest()
	if err != nil {
		return nil, err
	}
	c.ConnectToEnvService(req)
	err = ls.Connect(sout)
	ls.Close()
	return &sin, err
}

func NewLogger(options LogInitOptions) (*Logger, error) {
	l := Logger{
		logLevel: options.Loglevel,
		socket:   options.LogServiceChannel,
		pid:      uint64(os.Getpid()),
	}
	if options.ConsoleWriter == nil && options.LogServiceChannel == nil {
		if options.Connector == nil {
			return nil, fmt.Errorf("Init Error: Writer, LogServiceChannel or Connector needs to be provided")
		}
		if sock, err := connectToLogger(options.Connector); err != nil {
			fmt.Fprintf(os.Stderr, "not able to conenct to log sink, will write logs to stderr: %s", err)
			l.writer.Store(os.Stderr)
		} else {
			l.socket = sock
		}
	} else if options.ConsoleWriter != nil {
		l.writer.Store(options.ConsoleWriter)
	}
	if err := l.setTags(options.Tags); err != nil {
		return nil, err
	}
	return &l, nil
}

func (l *Logger) logToWriter(writer io.Writer, time zx.Time, logLevel LogLevel, tag, msg string) error {
	if len(l.tagString) != 0 {
		if len(tag) != 0 {
			tag = fmt.Sprintf("%s, %s", l.tagString, tag)
		} else {
			tag = l.tagString
		}
	}
	_, err := io.WriteString(writer, fmt.Sprintf("[%05d.%06d][%d][0][%s] %s: %s\n", time/1000000000, (time/1000)%1000000, l.pid, tag, logLevel, msg))
	return err
}

func (l *Logger) logToSocket(time zx.Time, logLevel LogLevel, tag, msg string) error {
	var buffer [SOCKET_BUFFER_LEN]byte
	binary.LittleEndian.PutUint64(buffer[0:8], l.pid)
	binary.LittleEndian.PutUint64(buffer[8:16], 0) // golang doesn't have tid
	binary.LittleEndian.PutUint64(buffer[16:24], uint64(time))
	binary.LittleEndian.PutUint32(buffer[24:28], uint32(logLevel))
	binary.LittleEndian.PutUint32(buffer[28:32], atomic.LoadUint32(&l.droppedLogs))
	pos := 32

	// Write global tags
	for _, tag := range l.tags {
		length := len(tag)
		if length == 0 {
			continue
		}
		buffer[pos] = byte(length)
		pos = pos + 1
		copy(buffer[pos:pos+length], tag)
		pos = pos + length
	}

	// Write local tags
	if len(tag) != 0 {
		length := len(tag)
		buffer[pos] = byte(length)
		pos = pos + 1
		copy(buffer[pos:pos+length], tag)
		pos = pos + length
	}

	//write msg
	buffer[pos] = 0
	pos = pos + 1
	errMsgTooLong := ErrMsgTooLong{""}
	if len(msg) >= SOCKET_BUFFER_LEN-pos {
		// truncate
		errMsgTooLong.Msg = msg[SOCKET_BUFFER_LEN-pos-4:]
		msg = msg[:SOCKET_BUFFER_LEN-pos-4]
		copy(buffer[pos:], msg)
		copy(buffer[pos+len(msg):], "...")
		pos = pos + len(msg) + 3
	} else {
		copy(buffer[pos:], msg)
		pos = pos + len(msg)
	}

	buffer[pos] = 0
	if _, err := l.socket.Write(buffer[:pos+1], 0); err != nil {
		atomic.AddUint32(&l.droppedLogs, 1)
		return err
	}
	if errMsgTooLong.Msg != "" {
		return errMsgTooLong
	}
	return nil
}

func (l *Logger) logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
	if l.logLevel > logLevel {
		return nil
	}
	time := zx.Sys_clock_get(0) //MONOTONIC
	msg := fmt.Sprintf(format, a...)
	if logLevel >= ErrorLevel {
		_, file, line, ok := runtime.Caller(callDepth)
		if !ok {
			file = "???"
			line = 0
		} else {
			short := file
			for i := len(file) - 1; i > 0; i-- {
				if file[i] == '/' {
					short = file[i+1:]
					break
				}
			}
			file = short
		}
		msg = fmt.Sprintf("%s(%d): %s ", file, line, msg)
	}
	if len(tag) > MAX_TAG_LEN {
		tag = tag[:MAX_TAG_LEN]
	}
	if logLevel == FatalLevel {
		defer os.Exit(1)
	}
	w := l.writer.Load()
	if w != nil {
		return l.logToWriter(w.(io.Writer), time, logLevel, tag, msg)
	} else {
		if err := l.logToSocket(time, logLevel, tag, msg); err != nil {
			if status, ok := err.(zx.Error); ok {
				if status.Status == zx.ErrPeerClosed || status.Status == zx.ErrBadState {
					l.ActivateFallbackMode()
					w = l.writer.Load()
					if w != nil {
						return l.logToWriter(w.(io.Writer), time, logLevel, tag, msg)
					}
				}
			}
			return err
		}
	}
	return nil
}

func (l *Logger) SetSeverity(logLevel LogLevel) {
	l.logLevel = logLevel
}

func (l *Logger) SetVerbosity(verbosity int) {
	l.logLevel = LogLevel(-verbosity)
}

func (l *Logger) Infof(format string, a ...interface{}) error {
	return l.logf(2, InfoLevel, "", format, a...)
}

func (l *Logger) Warnf(format string, a ...interface{}) error {
	return l.logf(2, WarningLevel, "", format, a...)
}

func (l *Logger) Errorf(format string, a ...interface{}) error {
	return l.logf(2, ErrorLevel, "", format, a...)
}

func (l *Logger) Fatalf(format string, a ...interface{}) error {
	return l.logf(2, FatalLevel, "", format, a...)
}

func (l *Logger) VLogf(verbosity int, format string, a ...interface{}) error {
	return l.logf(2, LogLevel(-verbosity), "", format, a...)
}

func (l *Logger) InfoTf(tag, format string, a ...interface{}) error {
	return l.logf(2, InfoLevel, tag, format, a...)
}

func (l *Logger) WarnTf(tag, format string, a ...interface{}) error {
	return l.logf(2, WarningLevel, tag, format, a...)
}

func (l *Logger) ErrorTf(tag, format string, a ...interface{}) error {
	return l.logf(2, ErrorLevel, tag, format, a...)
}

func (l *Logger) FatalTf(tag, format string, a ...interface{}) error {
	return l.logf(2, FatalLevel, tag, format, a...)
}

func (l *Logger) VLogTf(verbosity int, tag, format string, a ...interface{}) error {
	return l.logf(2, LogLevel(-verbosity), tag, format, a...)
}

var defaultLogger *Logger

func logf(callDepth int, logLevel LogLevel, tag string, format string, a ...interface{}) error {
	l := GetDefaultLogger()
	if l != nil {
		return l.logf(callDepth+1, logLevel, tag, format, a...)
	} else {
		return ErrNotInitialized
	}
}

// Public APIs for default logger

func GetDefaultLogger() *Logger {
	return defaultLogger
}

func InitDefaultLogger(c *context.Connector) error {
	options := GetDefaultInitOptions()
	options.Connector = c
	return InitDefaultLoggerWithConfig(options)
}

func InitDefaultLoggerWithTags(c *context.Connector, tags ...string) error {
	o := GetDefaultInitOptions()
	o.Tags = tags
	o.Connector = c
	return InitDefaultLoggerWithConfig(o)
}

func InitDefaultLoggerWithConfig(options LogInitOptions) error {
	if defaultLogger != nil {
		return ErrInitialized
	}

	if l, err := NewLogger(options); err != nil {
		return err
	} else {
		defaultLogger = l
	}
	return nil
}

func SetSeverity(logLevel LogLevel) {
	if l := GetDefaultLogger(); l != nil {
		l.logLevel = logLevel
	}
}

func SetVerbosity(verbosity int) {
	if l := GetDefaultLogger(); l != nil {
		l.logLevel = LogLevel(-verbosity)
	}
}

func Infof(format string, a ...interface{}) error {
	return logf(2, InfoLevel, "", format, a...)
}

func Warnf(format string, a ...interface{}) error {
	return logf(2, WarningLevel, "", format, a...)
}

func Errorf(format string, a ...interface{}) error {
	return logf(2, ErrorLevel, "", format, a...)
}

func Fatalf(format string, a ...interface{}) error {
	return logf(2, FatalLevel, "", format, a...)
}

func VLogf(verbosity int, format string, a ...interface{}) error {
	return logf(2, LogLevel(-verbosity), "", format, a...)
}

func InfoTf(tag, format string, a ...interface{}) error {
	return logf(2, InfoLevel, tag, format, a...)
}

func WarnTf(tag, format string, a ...interface{}) error {
	return logf(2, WarningLevel, tag, format, a...)
}

func ErrorTf(tag, format string, a ...interface{}) error {
	return logf(2, ErrorLevel, tag, format, a...)
}

func FatalTf(tag, format string, a ...interface{}) error {
	return logf(2, FatalLevel, tag, format, a...)
}

func VLogTf(verbosity int, tag, format string, a ...interface{}) error {
	return logf(2, LogLevel(-verbosity), tag, format, a...)
}

func ToErrMsgTooLong(e error) *ErrMsgTooLong {
	if err, ok := e.(ErrMsgTooLong); ok {
		return &err
	} else {
		return nil
	}
}