/*
NewRedis - Creates a Redis using the provided configuration.
*/
func NewRedis(config Config, logger *log.Logger) *Redis {
	return &Redis{
		logger: logger.NewModule(":redis_auth"),
		config: config,
		pool:   newPool(config.RedisConfig),
	}
}

/*
NewFile - Creates an File using the provided configuration.
*/
func NewFile(config Config, logger *log.Logger) *File {
	fa := File{
		logger: logger.NewModule(":fs_auth"),
		config: config,
		paths:  []string{},
		mutex:  &sync.RWMutex{},
	}
	go fa.loop()
	return &fa
}

/*
NewWebsocketServer - Creates a new HTTP websocket client.
*/
func NewWebsocketServer(
	config HTTPBinderConfig,
	socket *websocket.Conn,
	binder lib.BinderPortal,
	closeChan <-chan bool,
	logger *log.Logger,
	stats *log.Stats,
) *WebsocketServer {
	return &WebsocketServer{
		config:    config,
		socket:    socket,
		binder:    binder,
		closeChan: closeChan,
		logger:    logger.NewModule(":socket"),
		stats:     stats,
	}
}

/*
NewHTTP - Creates an HTTP using the provided configuration.
*/
func NewHTTP(config Config, logger *log.Logger, stats *log.Stats) *HTTP {
	authorizer := HTTP{
		logger: logger.NewModule(":http_auth"),
		stats:  stats,
		config: config,
		mutex:  sync.RWMutex{},

		tokensCreate:   tokensMap{},
		tokensJoin:     tokensMap{},
		tokensReadOnly: tokensMap{},
	}

	authorizer.createHandler = authorizer.createGenerateTokenHandler(authorizer.tokensCreate)
	authorizer.joinHandler = authorizer.createGenerateTokenHandler(authorizer.tokensJoin)
	authorizer.readOnlyHandler = authorizer.createGenerateTokenHandler(authorizer.tokensReadOnly)

	return &authorizer
}

/*
NewAuthMiddleware - Create a new leaps AuthMiddleware.
*/
func NewAuthMiddleware(
	config AuthMiddlewareConfig,
	logger *log.Logger,
	stats *log.Stats,
) (*AuthMiddleware, error) {
	auth := AuthMiddleware{
		config:   config,
		accounts: map[string]string{},
		logger:   logger.NewModule(":basic_auth"),
		stats:    stats,
	}
	if config.Enabled {
		if 0 == len(config.PasswdFilePath) {
			return nil, ErrInvalidHtpasswdPath
		}
		if err := auth.accountsFromFile(config.PasswdFilePath); err != nil {
			return nil, fmt.Errorf("htpasswd file read error: %v", err)
		}
	}
	return &auth, nil
}

/*
NewInternalServer - Create a new leaps InternalServer.
*/
func NewInternalServer(
	admin LeapAdmin,
	config InternalServerConfig,
	logger *log.Logger,
	stats *log.Stats,
) (*InternalServer, error) {
	auth, err := NewAuthMiddleware(config.HTTPAuth, logger, stats)
	if err != nil {
		return nil, err
	}
	httpServer := InternalServer{
		config: config,
		admin:  admin,
		logger: logger.NewModule(":http_admin"),
		stats:  stats,
		mux:    http.NewServeMux(),
		auth:   auth,
	}

	// Register handling for static files
	if len(httpServer.config.StaticFilePath) > 0 {
		if len(httpServer.config.Path) == 0 {
			return nil, ErrInvalidStaticPath
		}
		// If the static file path is relative then we use the location of the binary to resolve it.
		if err := binpath.FromBinaryIfRelative(&httpServer.config.StaticFilePath); err != nil {
			return nil, fmt.Errorf("relative path for static files could not be resolved: %v", err)
		}
		httpServer.mux.Handle(httpServer.config.Path,
			httpServer.auth.WrapHandler( // Auth wrap
				http.StripPrefix(httpServer.config.Path, // File strip prefix wrap
					http.FileServer(http.Dir(httpServer.config.StaticFilePath))))) // File serve handler
	}

	httpServer.registerEndpoints()

	return &httpServer, nil
}

/*
NewCurator - Creates and returns a fresh curator, and launches its internal loop.
*/
func NewCurator(
	config CuratorConfig,
	log *log.Logger,
	stats *log.Stats,
	auth auth.Authenticator,
	store store.Store,
) (*Curator, error) {

	curator := Curator{
		config:        config,
		store:         store,
		log:           log.NewModule(":curator"),
		stats:         stats,
		authenticator: auth,
		openBinders:   make(map[string]*Binder),
		errorChan:     make(chan BinderError, 10),
		closeChan:     make(chan struct{}),
		closedChan:    make(chan struct{}),
	}
	go curator.loop()

	return &curator, nil
}

/*
NewBinder - Creates a binder targeting an existing document determined via an ID. Must provide a
store.Store to acquire the document and apply future updates to.
*/
func NewBinder(
	id string,
	block store.Store,
	config BinderConfig,
	errorChan chan<- BinderError,
	log *log.Logger,
	stats *log.Stats,
) (*Binder, error) {

	binder := Binder{
		ID:               id,
		config:           config,
		model:            CreateTextModel(config.ModelConfig),
		block:            block,
		log:              log.NewModule(":binder"),
		stats:            stats,
		clients:          make(map[string]BinderClient),
		subscribeChan:    make(chan BinderSubscribeBundle),
		transformChan:    make(chan TransformSubmission),
		messageChan:      make(chan MessageSubmission),
		usersRequestChan: make(chan usersRequestObj),
		exitChan:         make(chan string),
		errorChan:        errorChan,
		closedChan:       make(chan struct{}),
	}
	binder.log.Debugln("Bound to document, attempting flush")

	if _, err := binder.flush(); err != nil {
		stats.Incr("binder.new.error", 1)
		return nil, err
	}
	go binder.loop()

	stats.Incr("binder.new.success", 1)
	return &binder, nil
}