package server

import (
	"context"
	"os"
	"os/signal"
	"os/user"
	"path/filepath"
	"strconv"
	"syscall"
	"time"

	"certmanager/internal/config"
	"certmanager/internal/database"
	"certmanager/internal/logic"
	"certmanager/pkg/aux509"
	"certmanager/pkg/logger"

	ghandler "certmanager/internal/grpc/handler"
	gservice "certmanager/internal/grpc/service"
	whandler "certmanager/internal/wrpc/handler"
	wservice "certmanager/internal/wrpc/service"
)

type Server struct {
	conf       *config.Config
	lg         *logic.Logic
	wsvc       *wservice.Service
	whand      *whandler.Handler
	gsvc       *gservice.Service
	ghand      *ghandler.Handler
	log        *logger.Logger
	db         *database.Database
	x509cert   []byte
	x509key    []byte
	x509caCert []byte
	x509caKey  []byte
}

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

func (srv *Server) Configure() error {
	var err error
	srv.conf = config.NewConfig()

	err = srv.conf.ReadFile()
	if err != nil {
		return err
	}
	err = srv.conf.ReadEnv()
	if err != nil {
		return err
	}
	err = srv.conf.ReadOpts()
	if err != nil {
		return err
	}

	return err
}

func (srv *Server) Build() error {
	var err error
	srv.log.Infof("Build server")

	// Create X509 certs
	srv.x509caCert, srv.x509caKey, err = aux509.CreateX509CACert(srv.conf.Hostname)
	if err != nil {
		return err
	}
	srv.x509cert, srv.x509key, err = aux509.CreateX509Cert(srv.conf.Hostname, srv.x509caKey)
	if err != nil {
		return err
	}
	// Create database
	db, err := database.NewDatabase(srv.conf.DataDir)
	if err != nil {
		return err
	}
	srv.db = db

	// Create logic
	logicConfig := &logic.LogicConfig{
		Auths:    srv.conf.Auths,
		Database: srv.db,
	}
	srv.lg, err = logic.NewLogic(logicConfig)
	if err != nil {
		return err
	}

	// Create whandler
	whandlerConfig := &whandler.HandlerConfig{
		Logic: srv.lg,
	}
	srv.whand, err = whandler.NewHandler(whandlerConfig)
	if err != nil {
		return err
	}
	// Create wservice
	wserviceConfig := &wservice.ServiceConfig{
		PortNum:  srv.conf.Wservice.PortNum,
		Hostname: srv.conf.Hostname,
		Handler:  srv.whand,
		X509Cert: srv.x509cert,
		X509Key:  srv.x509key,
	}
	srv.wsvc, err = wservice.NewService(wserviceConfig)
	if err != nil {
		return err
	}
	err = srv.wsvc.Build()
	if err != nil {
		return err
	}
	// Create ghandler
	ghandlerConfig := &ghandler.HandlerConfig{
		Logic: srv.lg,
	}
	srv.ghand = ghandler.NewHandler(ghandlerConfig)
	if err != nil {
		return err
	}
	// Create gservice
	gserviceConfig := &gservice.ServiceConfig{
		PortNum:  srv.conf.Gservice.PortNum,
		Hostname: srv.conf.Hostname,
		Handler:  srv.ghand,
		Logic:    srv.lg,
		X509Cert: srv.x509cert,
		X509Key:  srv.x509key,
	}
	srv.gsvc = gservice.NewService(gserviceConfig)
	if err != nil {
		return err
	}
	return err
}

func (srv *Server) Run() error {
	var err error
	// Log configuration
	yamlConfig, err := srv.conf.Yaml()
	if err != nil {
		return err
	}
	srv.log.Debugf("Server configuration:\n%s\n", yamlConfig)

	// Show current user
	currUser, err := user.Current()
	if err != nil {
		return err
	}
	srv.log.Infof("Running server as user %s", currUser.Username)

	// Initialize database
	err = srv.db.InitDatabase()
	if err != nil {
		return err
	}

	// Seed accounts
	ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
	_, err = srv.lg.SeedAccount(ctx)
	if err != nil {
		return err
	}

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

	// Run wservice
	startWservice := func(svc *wservice.Service, done chan error) {
		err = svc.Run()
		if err != nil {
			srv.log.Errorf("Service error: %v", err)
			done <- err
		}
	}
	go startWservice(srv.wsvc, wdone)

	// Run gservice
	startGservice := func(svc *gservice.Service, done chan error) {
		err = svc.Run()
		if err != nil {
			srv.log.Errorf("Service error: %v", err)
			done <- err
		}
	}
	go startGservice(srv.gsvc, gdone)

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

	select {
	case signal = <-sigs:
		srv.log.Infof("Services stopped by signal: %v", signal)
		srv.wsvc.Stop()
		srv.gsvc.Stop()
	case err = <-gdone:
		srv.log.Infof("Service stopped by gservice error: %v", err)
		srv.wsvc.Stop()
	case err = <-wdone:
		srv.log.Infof("Service stopped by wservice error: %v", err)
		srv.gsvc.Stop()
	}
	return err
}

func (srv *Server) PseudoFork() error {
	const successExit int = 0
	var keyEnv string = "IMX0LTSELMRF8KASWER"
	var err error

	_, isChild := os.LookupEnv(keyEnv)
	switch {
	case !isChild:
		os.Setenv(keyEnv, "TRUE")

		procAttr := syscall.ProcAttr{}
		cwd, err := os.Getwd()
		if err != nil {
			return err
		}
		var sysFiles = make([]uintptr, 3)
		sysFiles[0] = uintptr(syscall.Stdin)
		sysFiles[1] = uintptr(syscall.Stdout)
		sysFiles[2] = uintptr(syscall.Stderr)

		procAttr.Files = sysFiles
		procAttr.Env = os.Environ()
		procAttr.Dir = cwd

		_, err = syscall.ForkExec(os.Args[0], os.Args, &procAttr)
		if err != nil {
			return err
		}
		os.Exit(successExit)
	case isChild:
		_, err = syscall.Setsid()
		if err != nil {
			return err
		}
	}
	os.Unsetenv(keyEnv)
	return err
}

func (srv *Server) Daemonize() error {
	var err error
	if srv.conf.Daemon {
		// Restart process process
		err = srv.PseudoFork()
		if err != nil {
			return err
		}

		// Redirect stdin
		nullFile, err := os.OpenFile("/dev/null", os.O_RDWR, 0)
		if err != nil {
			return err
		}
		err = syscall.Dup2(int(nullFile.Fd()), int(os.Stdin.Fd()))
		if err != nil {
			return err
		}
		// Redirect stderr and stout
		logdir := filepath.Dir(srv.conf.LogPath)
		err = os.MkdirAll(logdir, 0750)
		if err != nil {
			return err
		}
		logFile, err := os.OpenFile(srv.conf.LogPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0640)
		if err != nil {
			return err
		}
		err = syscall.Dup2(int(logFile.Fd()), int(os.Stdout.Fd()))
		if err != nil {
			return err
		}
		err = syscall.Dup2(int(logFile.Fd()), int(os.Stderr.Fd()))
		if err != nil {
			return err
		}
		// Write process ID
		rundir := filepath.Dir(srv.conf.RunPath)
		err = os.MkdirAll(rundir, 0750)
		if err != nil {
			return err
		}
		pidFile, err := os.OpenFile(srv.conf.RunPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
		if err != nil {
			return err
		}
		defer pidFile.Close()
		currPid := os.Getpid()
		_, err = pidFile.WriteString(strconv.Itoa(currPid))
		if err != nil {
			return err
		}
	}
	return err
}