package starnotify

import (
	"b612.me/notify"
	"context"
	"errors"
	"io"
	"net"
	"sync"
)

var (
	cmu        sync.RWMutex
	smu        sync.RWMutex
	starClient map[string]notify.Client
	starServer map[string]notify.Server
)

func init() {
	starClient = make(map[string]notify.Client)
	starServer = make(map[string]notify.Server)
}

func NewClient(key string) notify.Client {
	client := notify.NewClient()
	storeClient(key, client)
	return client
}

func NewModernPSKClient(key string, sharedSecret []byte, opts *notify.ModernPSKOptions) (notify.Client, error) {
	client := notify.NewClient()
	if err := notify.UseModernPSKClient(client, sharedSecret, opts); err != nil {
		return nil, err
	}
	storeClient(key, client)
	return client, nil
}

func NewLegacySecurityClient(key string) notify.Client {
	client := notify.NewClient()
	notify.UseLegacySecurityClient(client)
	storeClient(key, client)
	return client
}

func DeleteClient(key string) (err error) {
	cmu.RLock()
	client, ok := starClient[key]
	cmu.RUnlock()
	if !ok {
		return errors.New("Not Exists Yet!")
	}
	if client.Status().Alive {
		err = client.Stop()
	}
	client = nil
	cmu.Lock()
	delete(starClient, key)
	cmu.Unlock()
	return err
}

func NewServer(key string) notify.Server {
	server := notify.NewServer()
	storeServer(key, server)
	return server
}

func NewModernPSKServer(key string, sharedSecret []byte, opts *notify.ModernPSKOptions) (notify.Server, error) {
	server := notify.NewServer()
	if err := notify.UseModernPSKServer(server, sharedSecret, opts); err != nil {
		return nil, err
	}
	storeServer(key, server)
	return server, nil
}

func NewLegacySecurityServer(key string) notify.Server {
	server := notify.NewServer()
	notify.UseLegacySecurityServer(server)
	storeServer(key, server)
	return server
}

func DeleteServer(key string) error {
	smu.RLock()
	server, ok := starServer[key]
	smu.RUnlock()
	if !ok {
		return errors.New("Not Exists Yet!")
	}
	if server.Status().Alive {
		server.Stop()
	}
	server = nil
	smu.Lock()
	delete(starServer, key)
	smu.Unlock()
	return nil
}

func S(key string) notify.Server {
	smu.RLock()
	server, ok := starServer[key]
	smu.RUnlock()
	if !ok {
		return nil
	}
	return server
}

func C(key string) notify.Client {
	cmu.RLock()
	client, ok := starClient[key]
	cmu.RUnlock()
	if !ok {
		return nil
	}
	return client
}

func Server(key string) (notify.Server, error) {
	smu.RLock()
	server, ok := starServer[key]
	smu.RUnlock()
	if !ok {
		return nil, errors.New("Not Exists Yet")
	}
	return server, nil
}

func Client(key string) (notify.Client, error) {
	cmu.RLock()
	client, ok := starClient[key]
	cmu.RUnlock()
	if !ok {
		return nil, errors.New("Not Exists Yet")
	}
	return client, nil
}

func OpenClientStreamFromReader(ctx context.Context, key string, src io.Reader, opt notify.StreamOpenCopyOptions) (notify.Stream, int64, error) {
	client, err := Client(key)
	if err != nil {
		return nil, 0, err
	}
	return notify.OpenClientStreamFromReader(ctx, client, src, opt)
}

func OpenServerLogicalStreamFromReader(ctx context.Context, key string, logical *notify.LogicalConn, src io.Reader, opt notify.StreamOpenCopyOptions) (notify.Stream, int64, error) {
	server, err := Server(key)
	if err != nil {
		return nil, 0, err
	}
	return notify.OpenServerLogicalStreamFromReader(ctx, server, logical, src, opt)
}

func OpenServerTransportStreamFromReader(ctx context.Context, key string, transport *notify.TransportConn, src io.Reader, opt notify.StreamOpenCopyOptions) (notify.Stream, int64, error) {
	server, err := Server(key)
	if err != nil {
		return nil, 0, err
	}
	return notify.OpenServerTransportStreamFromReader(ctx, server, transport, src, opt)
}

func CopyStreamToWriter(ctx context.Context, stream notify.Stream, dst io.Writer, opt notify.StreamCopyOptions) (int64, error) {
	return notify.CopyStreamToWriter(ctx, stream, dst, opt)
}

func NewTransferSourceFromReader(src io.Reader, size int64) (notify.TransferReaderAt, error) {
	return notify.NewTransferSourceFromReader(src, size)
}

func NewTransferSinkFromWriter(dst io.Writer) (notify.TransferWriterAt, error) {
	return notify.NewTransferSinkFromWriter(dst)
}

func NewTransferReaderFromSource(source notify.TransferReaderAt, offset int64) (io.Reader, error) {
	return notify.NewTransferReaderFromSource(source, offset)
}

func NewTransferWriterFromSink(sink notify.TransferWriterAt, offset int64) (io.Writer, error) {
	return notify.NewTransferWriterFromSink(sink, offset)
}

func UseModernPSKClient(key string, sharedSecret []byte, opts *notify.ModernPSKOptions) error {
	client, err := Client(key)
	if err != nil {
		return err
	}
	return notify.UseModernPSKClient(client, sharedSecret, opts)
}

func UseModernPSKServer(key string, sharedSecret []byte, opts *notify.ModernPSKOptions) error {
	server, err := Server(key)
	if err != nil {
		return err
	}
	return notify.UseModernPSKServer(server, sharedSecret, opts)
}

func UseLegacySecurityClient(key string) error {
	client, err := Client(key)
	if err != nil {
		return err
	}
	notify.UseLegacySecurityClient(client)
	return nil
}

func UseLegacySecurityServer(key string) error {
	server, err := Server(key)
	if err != nil {
		return err
	}
	notify.UseLegacySecurityServer(server)
	return nil
}

func UseSignalReliabilityClient(key string, opts *notify.SignalReliabilityOptions) error {
	client, err := Client(key)
	if err != nil {
		return err
	}
	return notify.UseSignalReliabilityClient(client, opts)
}

func UseSignalReliabilityServer(key string, opts *notify.SignalReliabilityOptions) error {
	server, err := Server(key)
	if err != nil {
		return err
	}
	return notify.UseSignalReliabilityServer(server, opts)
}

func ConnectClientWithRetry(key string, network string, addr string, opts *notify.ConnectRetryOptions) error {
	return ConnectClientWithRetryCtx(context.Background(), key, network, addr, opts)
}

func ConnectClientWithRetryCtx(ctx context.Context, key string, network string, addr string, opts *notify.ConnectRetryOptions) error {
	client, err := Client(key)
	if err != nil {
		return err
	}
	return notify.ConnectClientWithRetry(ctx, client, network, addr, opts)
}

func ConnectClientFactoryWithRetry(key string, dialFn func(context.Context) (net.Conn, error), opts *notify.ConnectRetryOptions) error {
	return ConnectClientFactoryWithRetryCtx(context.Background(), key, dialFn, opts)
}

func ConnectClientFactoryWithRetryCtx(ctx context.Context, key string, dialFn func(context.Context) (net.Conn, error), opts *notify.ConnectRetryOptions) error {
	client, err := Client(key)
	if err != nil {
		return err
	}
	return notify.ConnectClientFactoryWithRetry(ctx, client, dialFn, opts)
}

func ListenServerWithRetry(key string, network string, addr string, opts *notify.ConnectRetryOptions) error {
	return ListenServerWithRetryCtx(context.Background(), key, network, addr, opts)
}

func ListenServerWithRetryCtx(ctx context.Context, key string, network string, addr string, opts *notify.ConnectRetryOptions) error {
	server, err := Server(key)
	if err != nil {
		return err
	}
	return notify.ListenServerWithRetry(ctx, server, network, addr, opts)
}

func GetSignalReliabilityStatsClient(key string) (notify.SignalReliabilityStats, error) {
	client, err := Client(key)
	if err != nil {
		return notify.SignalReliabilityStats{}, err
	}
	return notify.GetSignalReliabilityStatsClient(client)
}

func GetSignalReliabilityStatsServer(key string) (notify.SignalReliabilityStats, error) {
	server, err := Server(key)
	if err != nil {
		return notify.SignalReliabilityStats{}, err
	}
	return notify.GetSignalReliabilityStatsServer(server)
}

func GetClientRuntimeSnapshot(key string) (notify.ClientRuntimeSnapshot, error) {
	client, err := Client(key)
	if err != nil {
		return notify.ClientRuntimeSnapshot{}, err
	}
	return notify.GetClientRuntimeSnapshot(client)
}

func GetServerRuntimeSnapshot(key string) (notify.ServerRuntimeSnapshot, error) {
	server, err := Server(key)
	if err != nil {
		return notify.ServerRuntimeSnapshot{}, err
	}
	return notify.GetServerRuntimeSnapshot(server)
}

func GetServerClientRuntimeSnapshot(serverKey string, clientID string) (notify.ClientConnRuntimeSnapshot, error) {
	return GetServerLogicalRuntimeSnapshot(serverKey, clientID)
}

func GetServerLogicalRuntimeSnapshot(serverKey string, clientID string) (notify.ClientConnRuntimeSnapshot, error) {
	server, err := Server(serverKey)
	if err != nil {
		return notify.ClientConnRuntimeSnapshot{}, err
	}
	logical := server.GetLogicalConn(clientID)
	if logical == nil {
		return notify.ClientConnRuntimeSnapshot{}, errors.New("Not Exists Yet")
	}
	return notify.GetLogicalConnRuntimeSnapshot(logical)
}

func GetServerLogicalConn(serverKey string, clientID string) (*notify.LogicalConn, error) {
	server, err := Server(serverKey)
	if err != nil {
		return nil, err
	}
	client := server.GetLogicalConn(clientID)
	if client == nil {
		return nil, errors.New("Not Exists Yet")
	}
	return client, nil
}

func GetServerCurrentTransportConn(serverKey string, clientID string) (*notify.TransportConn, bool, error) {
	server, err := Server(serverKey)
	if err != nil {
		return nil, false, err
	}
	transport := server.GetCurrentTransportConn(clientID)
	if transport == nil {
		if server.GetLogicalConn(clientID) == nil {
			return nil, false, errors.New("Not Exists Yet")
		}
		return nil, false, nil
	}
	return transport, true, nil
}

func GetServerClientTransportRuntimeSnapshot(serverKey string, clientID string) (notify.TransportConnRuntimeSnapshot, bool, error) {
	return GetServerTransportRuntimeSnapshot(serverKey, clientID)
}

func GetServerTransportRuntimeSnapshot(serverKey string, clientID string) (notify.TransportConnRuntimeSnapshot, bool, error) {
	server, err := Server(serverKey)
	if err != nil {
		return notify.TransportConnRuntimeSnapshot{}, false, err
	}
	transport := server.GetCurrentTransportConn(clientID)
	if transport == nil {
		if server.GetLogicalConn(clientID) == nil {
			return notify.TransportConnRuntimeSnapshot{}, false, errors.New("Not Exists Yet")
		}
		return notify.TransportConnRuntimeSnapshot{}, false, nil
	}
	snapshot, err := notify.GetTransportConnRuntimeSnapshot(transport)
	if err != nil {
		return notify.TransportConnRuntimeSnapshot{}, false, err
	}
	return snapshot, true, nil
}

func GetServerDetachedClientRuntimeSnapshots(serverKey string) ([]notify.ClientConnRuntimeSnapshot, error) {
	server, err := Server(serverKey)
	if err != nil {
		return nil, err
	}
	return notify.GetServerDetachedClientRuntimeSnapshots(server)
}

func GetClientTransferSnapshots(key string) ([]notify.TransferSnapshot, error) {
	client, err := Client(key)
	if err != nil {
		return nil, err
	}
	return notify.GetClientTransferSnapshots(client)
}

func GetServerTransferSnapshots(key string) ([]notify.TransferSnapshot, error) {
	server, err := Server(key)
	if err != nil {
		return nil, err
	}
	return notify.GetServerTransferSnapshots(server)
}

func GetClientTransferSnapshotByID(key string, transferID string) (notify.TransferSnapshot, bool, error) {
	client, err := Client(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetClientTransferSnapshotByID(client, transferID)
}

func GetClientTransferSnapshotByIDScope(key string, transferID string, scope string) (notify.TransferSnapshot, bool, error) {
	client, err := Client(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetClientTransferSnapshotByIDScope(client, transferID, scope)
}

func GetClientTransferSnapshotByIDQuery(key string, transferID string, query notify.TransferSnapshotQuery) (notify.TransferSnapshot, bool, error) {
	client, err := Client(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetClientTransferSnapshotByIDQuery(client, transferID, query)
}

func GetServerTransferSnapshotByID(key string, transferID string) (notify.TransferSnapshot, bool, error) {
	server, err := Server(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetServerTransferSnapshotByID(server, transferID)
}

func GetServerTransferSnapshotByIDScope(key string, transferID string, scope string) (notify.TransferSnapshot, bool, error) {
	server, err := Server(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetServerTransferSnapshotByIDScope(server, transferID, scope)
}

func GetServerTransferSnapshotByIDQuery(key string, transferID string, query notify.TransferSnapshotQuery) (notify.TransferSnapshot, bool, error) {
	server, err := Server(key)
	if err != nil {
		return notify.TransferSnapshot{}, false, err
	}
	return notify.GetServerTransferSnapshotByIDQuery(server, transferID, query)
}

func GetClientFileTransferActiveSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	client, err := Client(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetClientFileTransferActiveSummaries(client)
}

func GetServerFileTransferActiveSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	server, err := Server(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetServerFileTransferActiveSummaries(server)
}

func GetClientFileTransferCompletedSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	client, err := Client(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetClientFileTransferCompletedSummaries(client)
}

func GetServerFileTransferCompletedSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	server, err := Server(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetServerFileTransferCompletedSummaries(server)
}

func GetClientFileTransferFailedSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	client, err := Client(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetClientFileTransferFailedSummaries(client)
}

func GetServerFileTransferFailedSummaries(key string) (notify.FileTransferSummaryGroup, error) {
	server, err := Server(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetServerFileTransferFailedSummaries(server)
}

func GetClientFileTransferLatestByFileID(key string, fileID string) (notify.FileTransferSummaryGroup, error) {
	client, err := Client(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetClientFileTransferLatestByFileID(client, fileID)
}

func GetServerFileTransferLatestByFileID(key string, fileID string) (notify.FileTransferSummaryGroup, error) {
	server, err := Server(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetServerFileTransferLatestByFileID(server, fileID)
}

func GetClientFileTransferLatestByFileIDQuery(key string, fileID string, query notify.FileTransferSummaryQuery) (notify.FileTransferSummaryGroup, error) {
	client, err := Client(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetClientFileTransferLatestByFileIDQuery(client, fileID, query)
}

func GetServerFileTransferLatestByFileIDQuery(key string, fileID string, query notify.FileTransferSummaryQuery) (notify.FileTransferSummaryGroup, error) {
	server, err := Server(key)
	if err != nil {
		return notify.FileTransferSummaryGroup{}, err
	}
	return notify.GetServerFileTransferLatestByFileIDQuery(server, fileID, query)
}

func storeClient(key string, client notify.Client) {
	cmu.Lock()
	starClient[key] = client
	cmu.Unlock()
}

func storeServer(key string, server notify.Server) {
	smu.Lock()
	starServer[key] = server
	smu.Unlock()
}