package gologger
  
  import (
  	"fmt"
  	"os"

  	"path/filepath"

  	"runtime"

  	"sync"

  	"time"

  )

  const MaxLogFileSize5MB int64 = 5 * 1024 * 1024
  const MaxLogFileSize1MB int64 = 1 * 1024 * 1024
  const MaxLogFileSize500KB int64 = 500 * 1024
  const MaxLogFileSize100KB int64 = 100 * 1024
  const MaxLogFileSize512B 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
  }

  var logger Logger

  func Init(eventFileName, errorFileName string) error {

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

  	var err error
  
  	// event file/dir
  	if eventFileName != "" {
  		err = os.Mkdir(EvtDirName, os.ModePerm)
  		if err != nil {
  			if !os.IsExist(err) {
  				fmt.Printf("logger: mkdir: couldn't create event log directory
  ")
  				return err
  			}

  		}

  		logger.eventFileName = eventFileName
  		path := filepath.Join(EvtDirName, eventFileName+timestamp+".txt")
  		logger.eventf, err = os.Create(path)
  		if err != nil {
  			fmt.Printf("logger: new: couldn't create event log file
  ")

  			return err

  		}
  	}

  	// error file/dir
  	if errorFileName != "" {
  		err = os.Mkdir(ErrDirName, os.ModePerm)
  		if err != nil {
  			if !os.IsExist(err) {
  				fmt.Printf("logger: new: couldn't create error log directory
  ")
  				return err
  			}
  		}

  		logger.errorFileName = errorFileName
  		path := filepath.Join(ErrDirName, errorFileName+timestamp+".txt")
  		logger.errorf, err = os.Create(path)
  		if err != nil {
  			fmt.Printf("logger: new: couldn't create error log file
  ")
  			return err
  		}

  	}

  	return nil
  }

  func Print(s string) {
  	fmt.Printf(time.Now().Format(time.RFC3339) + ": " + s + "
  ")
  }

  func 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 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 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 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 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() >= MaxLogFileSize100KB {
  		// 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() >= MaxLogFileSize100KB {
  		// 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
  ")
  		}
  	}
  }