ppc_amnet/amnet-native/app/ServerCardIn.tsx

import {BSON} from "realm";
import React, {useCallback, useEffect, useLayoutEffect, useMemo, useState} from "react";
import {ActivityIndicator, Button, Paragraph, Title, useTheme} from "react-native-paper";
import {Alert, RefreshControl, ScrollView, Share, StyleSheet, Text, TouchableOpacity, View} from "react-native";
import {
    CircleCheck, CircleDot, CreditCard, Nfc, Plus, SmartphoneNfcIcon,
    Share as ShareIcon, WifiOff, TvMinimalPlay, Star
} from "lucide-react-native";

import {EmptyStatePlaceholder} from "../components/EmptyStatePlaceholder";
import {AMUIStatusAlert} from "../components/AMUIStatusAlert";
import {AMUICardDetail} from "../components/AMUICard";
import {AimeCard} from "../components/AimeCard";

import RealmContext from "../models/RealmContext";
import {AMServer} from "../models/AMServer";
import {AMCard} from "../models/AMCard";
import ObjectId = BSON.ObjectId;
import {
    AMServerConnectionInfo,
    AMServerInstanceMetrics,
    fetchServerInfo,
    getGameName,
    performCardIn
} from "amnet-shared";

const {useRealm, useQuery, useObject} = RealmContext;

export default function ServerCardIn({route, navigation}) {
    const realm = useRealm();
    const theme = useTheme();

    // card listing state
    const cards = useQuery({
        type: AMCard,
        query: q => q.sorted("lastUsed", true)
    });

    const [defaultCard, setDefaultCard] = useState<AMCard>(null);
    const [selectedCard, setSelectedCard] = useState<AMCard>(null);
    const [cardInCompleted, setCardInCompleted] = useState<boolean>(null);

    const unselectedCards = useMemo(() => {
        // protect against selected card being removed
        switch (selectedCard?.isValid()) {
            case true:
                return cards.filter(x => !x._id.equals(selectedCard._id));

            // clear out invalid 
            case false:
                setSelectedCard(null);
                return cards;

            default:
                return cards;
        }
    }, [cards, selectedCard]);

    // server state
    const [serverRefreshing, setServerRefreshing] = useState<boolean>(false);
    const [serverReloadCounter, setServerReloadCounter] = useState<number>(0);
    const [serverPreviousGameId, setServerPreviousGameId] = useState<string | null>(null);
    const [connectionTestResult, setConnectionTestResult] = useState<boolean | null>(null);

    let {serverId} = route.params;
    const server = useObject(AMServer, ObjectId.createFromHexString(serverId));

    useLayoutEffect(() => {
        if (server?.isValid() !== true) {
            return;
        }

        navigation.setOptions({
            title: server.serverName,
            headerRight: () => (
                <TouchableOpacity onPress={() => Share.share({url: server.shareUrl})}>
                    <ShareIcon/>
                </TouchableOpacity>
            )
        });
    }, [navigation, server]);

    // card selection, server connection checks
    useEffect(() => {
        if (server?.isValid() !== true) {
            navigation.goBack();

            if (!server) {
                Alert.alert("Server not found", "The server you are looking for does not exist.");
            }

            return;
        }

        if (defaultCard?.isValid() === false) {
            setDefaultCard(null);
        }

        // select a card if there's none selected
        if (selectedCard?.isValid() !== true) {
            setSelectedCard(cards.length ? cards[0] : null);
        }

        const abortController = new AbortController();
        fetchServerInfo(server.serverAddress, abortController.signal).then(r => {
            if (!r) {
                setConnectionTestResult(false);
                return;
            }

            setConnectionTestResult(true);
            realm.write(() => {
                server.lastUsed = new Date();
                Object.keys(r).forEach(x => server[x] = r[x]);
            });

            const matchingGameCard = cards.find(x => x.lastUsedGameId === server.gameId);
            if (matchingGameCard) {
                setDefaultCard(matchingGameCard);
            }

            if (server.gameId !== serverPreviousGameId) {
                setServerPreviousGameId(server.gameId);
                setSelectedCard(matchingGameCard || cards[0]);
            }
        }).catch(() => {
            setConnectionTestResult(false);
        }).finally(() => {
            setServerRefreshing(false);
        });

        const timeout = setTimeout(() => abortController.abort(), 5000);
        return () => {
            clearTimeout(timeout);
            abortController.abort();
        }
    }, [serverId, serverReloadCounter, realm]);

    // card in callback
    const cardInCallback = useCallback(() => {
        setCardInCompleted(false);

        const abortController = new AbortController();
        performCardIn(server, {cardId: selectedCard.code}, abortController.signal).then(async r => {
            const now = new Date();
            realm.write(() => {
                server.lastUsed = now;
                selectedCard.lastUsed = now;
                selectedCard.lastUsedGameId = server.gameId;
            });

            // set default card if there's a game id provided by the server
            if (server.gameId) {
                setDefaultCard(selectedCard);
            }

            setCardInCompleted(r);
        }).catch(() => {
            setCardInCompleted(false);
        }).finally(() => {
            setTimeout(() => setCardInCompleted(null), 3000);
        });

        setTimeout(() => abortController.abort(), 5000);
        return () => abortController.abort();
    }, [server, selectedCard]);

    const performRefresh = () => {
        setServerRefreshing(true);
        setServerReloadCounter(serverReloadCounter + 1);
    }

    const gameName = useMemo(() => getGameName(server.gameId), [server.gameId]);
    const disableCardIn = useMemo(() => cardInCompleted !== null || !connectionTestResult, [cardInCompleted, connectionTestResult]);

    if (connectionTestResult === null) {
        return (
            <View style={{flex: 1, justifyContent: "center", alignItems: "center", gap: 10}}>
                <ActivityIndicator animating/>
                <Paragraph>Connecting to server...</Paragraph>
            </View>
        )
    }

    return (
        <ScrollView contentInsetAdjustmentBehavior="automatic"
                    contentContainerStyle={{...styles.container, paddingTop: connectionTestResult ? 0 : 10}}
                    refreshControl={<RefreshControl refreshing={serverRefreshing} onRefresh={performRefresh}/>}>
            <StatusAlert server={server} connectionEstablished={connectionTestResult}/>
            <View style={styles.section}>
                <Title style={styles.sectionTitle}>{gameName ? `Play ${gameName}` : "Selected Card"}</Title>
                {selectedCard ? <>
                        <AimeCard actionDisabled
                                  card={selectedCard}
                                  actionIcon={<CircleCheck color="green" size={24}/>}>
                            {defaultCard?.code == selectedCard.code && <DefaultCardDetail/>}
                        </AimeCard>
                        <Button textColor="white"
                                onPress={cardInCallback}
                                disabled={disableCardIn}
                                contentStyle={{flexDirection: 'row-reverse'}}
                                mode={connectionTestResult ? "contained" : "outlined"}
                                buttonColor={cardInCompleted === false ? "red" : "green"}
                                icon={() => <Nfc color={disableCardIn ? "gray" : "white"} size={18}/>}>
                            {cardInCompleted === null ? "Card In" : cardInCompleted ? "Card In Success" : "Failed"}
                        </Button>
                    </>
                    : <View style={styles.emptyPlaceholderView}>
                        <EmptyStatePlaceholder message="No card selected" icon={<CreditCard color="gray"/>}/>
                        <Button mode="text"
                                icon={() => <Plus color={theme.colors.primary} size={18}/>}
                                onPress={() => navigation.navigate('add-card')}>
                            Add card
                        </Button>
                    </View>}
            </View>

            {cards.length > 0 && (
                <View style={styles.section}>
                    <Title style={styles.sectionTitle}>Additional Cards</Title>
                    <Button mode="contained"
                            textColor="white"
                            buttonColor={theme.colors.tertiary}
                            icon={() => <Plus color="white" size={18}/>}
                            contentStyle={{flexDirection: 'row-reverse'}}
                            onPress={() => navigation.navigate('add-card')}>
                        Add card
                    </Button>

                    {unselectedCards.length
                        ? unselectedCards.map((card: AMCard) => (
                            <AimeCard card={card}
                                      key={card._id.toHexString()}
                                      actionIcon={<CircleDot color={theme.colors.tertiary} size={24}/>}
                                      onPress={() => setSelectedCard(card)}>
                                {defaultCard?.code == card.code && <DefaultCardDetail/>}
                            </AimeCard>))
                        : <View style={styles.emptyPlaceholderView}>
                            <EmptyStatePlaceholder message="No additional cards" icon={<SmartphoneNfcIcon color="gray"/>}/>
                        </View>}
                </View>)}
        </ScrollView>
    )
}

function StatusAlert(props: {
    server: AMServerConnectionInfo & Partial<AMServerInstanceMetrics>,
    connectionEstablished: boolean
}) {
    if (!props.connectionEstablished) {
        return (
            <AMUIStatusAlert color="red" icon={WifiOff} title="Connection Failed">
                <Paragraph>
                    There was an issue connecting to <Paragraph
                    style={{fontFamily: "JetBrainsMono_400Regular"}}>{props.server.serverAddress}</Paragraph>.
                    Check the network connection and try again.
                </Paragraph>
            </AMUIStatusAlert>
        )
    }

    // don't show if undefined (some older server versions)
    if (props.server.timeSinceLastPoll === null) {
        return (
            <AMUIStatusAlert color="#822eff" icon={TvMinimalPlay} title="Server Startup">
                <Paragraph>
                    Scanning a card below may not have any effect until the service has fully started up.
                </Paragraph>
            </AMUIStatusAlert>
        )
    }

    return null;
}

function DefaultCardDetail() {
    return (
        <>
            {/* spacer */}
            <View></View>
            <AMUICardDetail>
                <Star size={18} color="goldenrod"/>
                <Text style={{color: "goldenrod"}}>Previously used with this game</Text>
            </AMUICardDetail>
        </>

    )
}

const styles = StyleSheet.create({
    section: {
        gap: 10
    },
    sectionTitle: {
        fontWeight: "bold"
    },
    emptyPlaceholderView: {
        marginVertical: 30,
        gap: 15
    },
    container: {
        paddingHorizontal: 16,
        paddingBottom: 80,
        gap: 20
    }
});