package gologger
  
  import (
  	"fmt"
  	"os"
  	"time"

  	"sync"

  )

  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
  }
  
  func NewLogger(eventFileName, errorFileName string) (*Logger, error) {
  	var l Logger
  	var err error

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

  
  	// create files
  	l.eventFileName = eventFileName
  	l.errorFileName = errorFileName
  
  	l.eventf, err = os.Create("./" + EvtDirName + "/" +
  		eventFileName + timestamp + ".txt")
  
  	if err != nil {
  		fmt.Printf("logger: new: couldn't create event log file
  ")
  		return &l, err
  	}
  
  	l.errorf, err = os.Create("./" + ErrDirName + "/" +
  		errorFileName + timestamp + ".txt")
  
  	if err != nil {
  		fmt.Printf("logger: new: couldn't create error log file
  ")
  		return &l, err
  	}
  
  	// 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 &l, 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 &l, err
  		}
  	}
  
  	return &l, nil
  }
  
  func (l *Logger) Close() {
  	// close files
  	err := l.eventf.Close()
  	if err != nil {
  		fmt.Printf("logger: on exit: couldn't close event log file
  ")
  	}
  
  	err = l.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
  		l.eventf, errnew = os.Create("./" + EvtDirName + "/" +
  			l.eventFileName + timestamp + ".txt")
  
  		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
  		l.errorf, errnew = os.Create("./" + ErrDirName + "/" +
  			l.errorFileName + timestamp + ".txt")
  
  		if errnew != nil {
  			fmt.Printf("logger: split: couldn't create error log file
  ")
  		}
  	}
  }
  
  func (l *Logger) LogEvent(event string) {

  	muEv.Lock()
  	defer muEv.Unlock()

  	l.eventf.WriteString(time.Now().Format(time.RFC3339) + ": " + event + "
  ")

  	l.splitEventLog()
  }
  
  func (l *Logger) LogError(err error) {

  	muEr.Lock()
  	defer muEr.Unlock()

  	l.errorf.WriteString(time.Now().Format(time.RFC3339) + ": " + err.Error() + "
  ")

  	l.splitErrorLog()
  }