package jsonlog

import (
    "encoding/json"
    "io"
    "os"
    "runtime/debug"
    "sync"
    "time"
)

// Define a Level type to represent the severity level for a log entry.
type Level int8

// Initialize constants which represent a specific severity level. We use the iota
// keyword as a shortcut to assign successive integer values to the constants.
const (
    LevelInfo  Level = iota // Has the value 0.
    LevelError              // Has the value 1.
    LevelFatal              // Has the value 2.
    LevelOff                // Has the value 3.
)

// Return a human-friendly string for the severity level.
func (l Level) String() string {
    switch l {
    case LevelInfo:
        return "INFO"
    case LevelError:
        return "ERROR"
    case LevelFatal:
        return "FATAL"
    default:
        return ""
    }
}

// Define a custom Logger type. This holds the output destination that the log entries
// will be written to, the minimum severity level that log entries will be written for,
// plus a mutex for coordinating the writes.
type Logger struct {
    out      io.Writer
    minLevel Level
    mu       sync.Mutex
}

// Return a new Logger instance which writes log entries at or above a minimum severity
// level to a specific output destination.
func New(out io.Writer, minLevel Level) *Logger {
    return &Logger{
        out:      out,
        minLevel: minLevel,
    }
}

// Declare some helper methods for writing log entries at the different levels. Notice
// that these all accept a map as the second parameter which can contain any arbitrary
// 'properties' that you want to appear in the log entry.
func (l *Logger) PrintInfo(message string, properties map[string]string) {
    l.print(LevelInfo, message, properties)
}

func (l *Logger) PrintError(err error, properties map[string]string) {
    l.print(LevelError, err.Error(), properties)
}

func (l *Logger) PrintFatal(err error, properties map[string]string) {
    l.print(LevelFatal, err.Error(), properties)
    os.Exit(1) // For entries at the FATAL level, we also terminate the application.
}

// Print is an internal method for writing the log entry.
func (l *Logger) print(level Level, message string, properties map[string]string) (int, error) {
    // If the severity level of the log entry is below the minimum severity for the
    // logger, then return with no further action.
    if level < l.minLevel {
        return 0, nil
    }

    // Declare an anonymous struct holding the data for the log entry.
    aux := struct {
        Level      string            `json:"level"`
        Time       string            `json:"time"`
        Message    string            `json:"message"`
        Properties map[string]string `json:"properties,omitempty"`
        Trace      string            `json:"trace,omitempty"`
    }{
        Level:      level.String(),
        Time:       time.Now().UTC().Format(time.RFC3339),
        Message:    message,
        Properties: properties,
    }

    // Include a stack trace for entries at the ERROR and FATAL levels.
    if level >= LevelError {
        aux.Trace = string(debug.Stack())
    }

    // Declare a line variable for holding the actual log entry text.
    var line []byte

    // Marshal the anonymous struct to JSON and store it in the line variable. If there
    // was a problem creating the JSON, set the contents of the log entry to be that
    // plain-text error message instead.
    line, err := json.Marshal(aux)
    if err != nil {
        line = []byte(LevelError.String() + ": unable to marshal log message: " + err.Error())
    }

    // Lock the mutex so that no two writes to the output destination can happen
    // concurrently. If we don't do this, it's possible that the text for two or more
    // log entries will be intermingled in the output.
    l.mu.Lock()
    defer l.mu.Unlock()

    // Write the log entry followed by a newline.
    return l.out.Write(append(line, '\n'))
}

// We also implement a Write() method on our Logger type so that it satisfies the 
// io.Writer interface. This writes a log entry at the ERROR level with no additional 
// properties.
func (l *Logger) Write(message []byte) (n int, err error) {
    return l.print(LevelError, string(message), nil)
}

package main

import (
    "context"
    "database/sql"
    "flag"
    "fmt"
    "net/http"
    "os"
    "time"

    "greenlight.alexedwards.net/internal/data"
    "greenlight.alexedwards.net/internal/jsonlog" // New import

    _ "github.com/lib/pq"
)

...

// Change the logger field to have the type *jsonlog.Logger, instead of
// *log.Logger.
type application struct {
    config config
    logger *jsonlog.Logger
    models data.Models
}

func main() {
    var cfg config

    flag.IntVar(&cfg.port, "port", 4000, "API server port")
    flag.StringVar(&cfg.env, "env", "development", "Environment (development|staging|production)")

    flag.StringVar(&cfg.db.dsn, "db-dsn", os.Getenv("GREENLIGHT_DB_DSN"), "PostgreSQL DSN")

    flag.IntVar(&cfg.db.maxOpenConns, "db-max-open-conns", 25, "PostgreSQL max open connections")
    flag.IntVar(&cfg.db.maxIdleConns, "db-max-idle-conns", 25, "PostgreSQL max idle connections")
    flag.StringVar(&cfg.db.maxIdleTime, "db-max-idle-time", "15m", "PostgreSQL max connection idle time")

    flag.Parse()

    // Initialize a new jsonlog.Logger which writes any messages *at or above* the INFO
    // severity level to the standard out stream.
    logger := jsonlog.New(os.Stdout, jsonlog.LevelInfo)

    db, err := openDB(cfg)
    if err != nil {
        // Use the PrintFatal() method to write a log entry containing the error at the
        // FATAL level and exit. We have no additional properties to include in the log
        // entry, so we pass nil as the second parameter.
        logger.PrintFatal(err, nil)
    }

    defer db.Close()
    // Likewise use the PrintInfo() method to write a message at the INFO level.
    logger.PrintInfo("database connection pool established", nil)

    app := &application{
        config: cfg,
        logger: logger,
        models: data.NewModels(db),
    }

    srv := &http.Server{
        Addr:         fmt.Sprintf(":%d", cfg.port),
        Handler:      app.routes(),
        IdleTimeout:  time.Minute,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 30 * time.Second,
    }

    // Again, we use the PrintInfo() method to write a "starting server" message at the
    // INFO level. But this time we pass a map containing additional properties (the
    // operating environment and server address) as the final parameter.
    logger.PrintInfo("starting server", map[string]string{
        "addr": srv.Addr,
        "env":  cfg.env,
    })

    err = srv.ListenAndServe()
    // Use the PrintFatal() method to log the error and exit.
    logger.PrintFatal(err, nil)
}

...

package main

...

func (app *application) logError(r *http.Request, err error) {
    // Use the PrintError() method to log the error message, and include the current 
    // request method and URL as properties in the log entry.
    app.logger.PrintError(err, map[string]string{
        "request_method": r.Method,
        "request_url":    r.URL.String(),
    })
}

...

func main() {

    ...

    // Initialize the custom logger.
    logger := jsonlog.New(os.Stdout, jsonlog.LevelInfo)

    ...

    srv := &http.Server{
        Addr:         fmt.Sprintf(":%d", cfg.port),
        Handler:      app.routes(),
        // Create a new Go log.Logger instance with the log.New() function, passing in 
        // our custom Logger as the first parameter. The "" and 0 indicate that the
        // log.Logger instance should not use a prefix or any flags.
        ErrorLog:     log.New(logger, "", 0),
        IdleTimeout:  time.Minute,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 30 * time.Second,
    }

    ...
}