package gologger
  
  import (
  	"fmt"
  	"os"

  	"path/filepath"

  	"runtime"

  	"sync"

  	"time"

  )

  type Option uint8
  
  const (
  	Events Option = 0x01
  	Errors Option = 0x02
  )
  
  const (
  	MaxLogSize5MB   int64 = 5 * 1024 * 1024
  	MaxLogSize1MB   int64 = 1 * 1024 * 1024
  	MaxLogSize500KB int64 = 500 * 1024
  	MaxLogSize100KB int64 = 100 * 1024
  	MaxLogSize512B  int64 = 512
  )

  const errDirName = "error-logs"
  const evtDirName = "event-logs"

  type Logger struct {

  	muEv   *sync.Mutex
  	eventf *os.File

  	eventFileName string

  
  	muEr   *sync.Mutex
  	errorf *os.File

  	errorFileName string

  
  	splitSize int64

  }

  func New(name string, flags Option, splitSize int64) (logger *Logger, err error) {
  	logger = &Logger{}

  	logger.splitSize = splitSize

  	timestamp := "_" + time.Now().Format(time.RFC3339)

  	// event file/dir

  	if flags&Events > 0 {

  		err = os.Mkdir(evtDirName, os.ModePerm)

  		if err != nil {
  			if !os.IsExist(err) {
  				fmt.Printf("logger: mkdir: couldn't create event log directory
  ")

  				return nil, err

  			}

  		}

  		logger.eventFileName = name + "-events"
  		path := filepath.Join(evtDirName, logger.eventFileName+timestamp+".txt")

  		logger.eventf, err = os.Create(path)
  		if err != nil {
  			fmt.Printf("logger: new: couldn't create event log file
  ")

  			return nil, err

  		}

  
  		logger.muEv = &sync.Mutex{}

  	}

  	// error file/dir

  	if flags&Errors > 0 {

  		err = os.Mkdir(errDirName, os.ModePerm)

  		if err != nil {
  			if !os.IsExist(err) {
  				fmt.Printf("logger: new: couldn't create error log directory
  ")

  				return nil, err

  			}
  		}

  		logger.errorFileName = name + "-errors"
  		path := filepath.Join(errDirName, logger.errorFileName+timestamp+".txt")

  		logger.errorf, err = os.Create(path)
  		if err != nil {
  			fmt.Printf("logger: new: couldn't create error log file
  ")

  			return nil, err

  		}

  
  		logger.muEr = &sync.Mutex{}

  	}

  	return logger, nil

  }

  func (logger *Logger) Print(s string) {

  	fmt.Printf(time.Now().Format(time.RFC3339) + ": " + s + "
  ")
  }

  func (logger *Logger) LogEvent(event string) {

  	if logger.eventf != nil {
  		logger.muEv.Lock()
  		defer logger.muEv.Unlock()
  		logger.eventf.WriteString(time.Now().Format(time.RFC3339) + ": " + event + "
  ")
  		logger.splitEventLog()
  	}

  }

  func (logger *Logger) LogError(comment string, err error) {

  	if logger.errorf != nil {
  		logger.muEr.Lock()
  		defer logger.muEr.Unlock()
  		logger.errorf.WriteString(time.Now().Format(time.RFC3339) + ": " + comment + ": " + err.Error() + "
  ")
  		logger.splitErrorLog()
  	}

  }

  func (logger *Logger) TraceEvent(event string) {

  	if logger.eventf != nil {
  		logger.muEv.Lock()
  		defer logger.muEv.Unlock()
  		_, file, line, ok := runtime.Caller(1)
  		var s string
  		if ok {
  			s = fmt.Sprintf("%s: %s %d: %s
  ", time.Now().Format(time.RFC3339), file, line, event)
  		} else {
  			s = fmt.Sprintf(time.Now().Format(time.RFC3339) + ": [can't retreive stack details]:" + event + "
  ")
  		}
  		logger.eventf.WriteString(s)
  		logger.splitEventLog()

  	}

  }

  func (logger *Logger) TraceError(err error) {

  	if logger.errorf != nil {
  		logger.muEr.Lock()
  		defer logger.muEr.Unlock()
  		_, file, line, ok := runtime.Caller(1)
  		var s string
  		if ok {
  			s = fmt.Sprintf("%s %s %d: %s
  ", time.Now().Format(time.RFC3339), file, line, err.Error())
  		} else {
  			s = fmt.Sprintf(time.Now().Format(time.RFC3339) + ": [can't retreive stack details]:" + err.Error() + "
  ")
  		}
  		logger.errorf.WriteString(s)
  		logger.splitErrorLog()

  	}

  }

  func (logger *Logger) Close() {

  	if logger.eventf != nil {
  		err := logger.eventf.Close()
  		if err != nil {
  			fmt.Printf("logger: on exit: couldn't close event log file
  ")
  		}

  	}

  	if logger.errorf != nil {
  		err := logger.errorf.Close()
  		if err != nil {
  			fmt.Printf("logger: on exit: couldn't close error log file
  ")
  		}

  	}
  }

  func (l *Logger) splitEventLog() {

  	timestamp := "_" + time.Now().Format(time.RFC3339)

  	evfstats, _ := l.eventf.Stat()

  	if evfstats.Size() >= l.splitSize {

  		// close old file
  		err := l.eventf.Close()
  		if err != nil {
  			fmt.Printf("logger: split: couldn't close event file
  ")
  			return
  		}
  		// open new file
  		var errnew error

  		path := filepath.Join(evtDirName, l.eventFileName+timestamp)

  		l.eventf, errnew = os.Create(path)

  
  		if errnew != nil {
  			fmt.Printf("logger: split: couldn't create event log file
  ")
  		}
  	}
  }

  func (l *Logger) splitErrorLog() {

  	timestamp := "_" + time.Now().Format(time.RFC3339)

  
  	erfstats, _ := l.errorf.Stat()

  	if erfstats.Size() >= l.splitSize {

  		// close old file
  		err := l.errorf.Close()
  		if err != nil {
  			fmt.Printf("logger: split: couldn't close error file
  ")
  			return
  		}
  		// open new file
  		var errnew error

  		path := filepath.Join(errDirName, l.errorFileName+timestamp)

  		l.errorf, errnew = os.Create(path)

  
  		if errnew != nil {
  			fmt.Printf("logger: split: couldn't create error log file
  ")
  		}
  	}
  }