package server

import (
	//"io/ioutil"
	"os"
	"os/signal"
	"os/user"
	//"os/user"
	//"path/filepath"
	//"strconv"
	//"sync"
	"syscall"
	//"time"

	"mstore/app/config"
	"mstore/app/handler"
	"mstore/app/logger"
	"mstore/app/maindb"
	"mstore/app/operator"
	"mstore/app/service"
	"mstore/app/storage"
)

type Server struct {
	conf *config.Config
	oper *operator.Operator
	svc  *service.Service
	mdb  *maindb.Database
	hand *handler.Handler
	logg *logger.Logger
	stor *storage.Storage
}

func NewServer() (*Server, error) {
	var err error
	srv := &Server{}
	srv.logg = logger.NewLogger("server")
	return srv, err
}

func (srv *Server) Handler() *handler.Handler {
	return srv.hand
}

func (srv *Server) Configure() error {
	var err error
	srv.logg.Infof("Server configure")
	srv.conf, err = config.NewConfig()
	if err != nil {
		return err
	}

	return err
}

func (srv *Server) Build() error {
	var err error
	srv.logg.Infof("Server build")

	// Database create
	srv.logg.Infof("Create database directory")
	dbdir := srv.conf.Database.Basepath
	err = os.MkdirAll(dbdir, 0750)
	if err != nil {
		return err
	}

	mdb := maindb.NewDatabase(dbdir)
	srv.logg.Infof("Open database")
	err = mdb.OpenDatabase()
	if err != nil {
		return err
	}
	srv.logg.Infof("Initialize database")
	err = mdb.InitDatabase()
	if err != nil {
		return err
	}
	srv.mdb = mdb

	// Storage create
	srv.logg.Infof("Create storage directory")
	datadir := srv.conf.Database.Basepath
	err = os.MkdirAll(datadir, 0750)
	if err != nil {
		return err
	}
	srv.logg.Infof("Create storage")
	store := storage.NewStorage(datadir)
	srv.stor = store

	// Operator create
	srv.logg.Infof("Create operator")
	operatorParams := &operator.OperatorParams{
		MainDB: srv.mdb,
		Store:  srv.stor,
	}
	srv.oper, err = operator.NewOperator(operatorParams)
	if err != nil {
		return err
	}
	// Handler create
	srv.logg.Infof("Create handler")
	handlerParams := &handler.HandlerParams{
		Operator: srv.oper,
	}
	srv.hand, err = handler.NewHandler(handlerParams)
	if err != nil {
		return err
	}
	// Service create
	serviceParams := &service.ServiceParams{
		Handler: srv.hand,
	}
	srv.logg.Infof("Create service")
	srv.svc, err = service.NewService(serviceParams)
	if err != nil {
		return err
	}
	// Service build
	err = srv.svc.Build()
	if err != nil {
		return err
	}

	return err
}

func (srv *Server) Run() error {
	var err error

	currUser, err := user.Current()
	if err != nil {
		return err
	}
	srv.logg.Infof("Server run as user %s", currUser.Username)

	sigs := make(chan os.Signal, 1)
	svcDone := make(chan error, 1)

	// Service run
	srv.logg.Infof("Start service")
	startService := func(svc *service.Service, done chan error) {
		err = svc.Run()
		if err != nil {
			srv.logg.Errorf("Service error: %v", err)
			done <- err
		}
	}
	go startService(srv.svc, svcDone)

	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	var signal os.Signal

	select {
	case signal = <-sigs:
		srv.logg.Infof("Services stopped by signal: %v", signal)
		srv.svc.Stop()
	case err = <-svcDone:
		srv.logg.Infof("Service stopped by service error: %v", err)
		srv.svc.Stop()
	}
	return err
}