package gologger
  
  import (
  	"fmt"
  	"os"

  	"path/filepath"

  	"runtime"

  	"sync"

  	"time"

  )

  var muEv = &sync.Mutex{}
  var muEr = &sync.Mutex{}

  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 {
  	eventf        *os.File
  	eventFileName string
  	errorf        *os.File
  	errorFileName string
  }

  var logger Logger

  func Init(eventFileName, errorFileName string) error {

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

  
  	// create directories to keep log files

  	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

  		}
  	}
  
  	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

  		}
  	}

  	// create files
  	logger.eventFileName = eventFileName
  	logger.errorFileName = errorFileName

  	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
  	}

  	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) {
  	muEv.Lock()
  	defer muEv.Unlock()
  	logger.eventf.WriteString(time.Now().Format(time.RFC3339) + ": " + event + "
  ")
  	logger.splitEventLog()
  }
  
  func LogError(comment string, err error) {
  	muEr.Lock()
  	defer muEr.Unlock()
  	logger.errorf.WriteString(time.Now().Format(time.RFC3339) + ": " + comment + ": " + err.Error() + "
  ")
  	logger.splitErrorLog()
  }

  func TraceEvent(event string) {

  	muEv.Lock()
  	defer 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) {

  	muEr.Lock()
  	defer 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() {

  	// close files

  	err := logger.eventf.Close()

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

  	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
  ")
  		}
  	}
  }