artemis/titles/wacca/schema/profile.py

from typing import Optional, Dict, List
from sqlalchemy import Table, Column, UniqueConstraint, PrimaryKeyConstraint, and_
from sqlalchemy.types import Integer, String, TIMESTAMP, Boolean, JSON
from sqlalchemy.schema import ForeignKey
from sqlalchemy.sql import func, select
from sqlalchemy.engine import Row
from sqlalchemy.dialects.mysql import insert

from core.data.schema import BaseData, metadata

profile = Table(
    "wacca_profile",
    metadata,
    Column("id", Integer, primary_key=True, nullable=False),
    Column(
        "user",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column("version", Integer),
    Column("username", String(8), nullable=False),
    Column("xp", Integer, server_default="0"),
    Column("wp", Integer, server_default="0"),
    Column("wp_total", Integer, server_default="0"),
    Column("wp_spent", Integer, server_default="0"),
    Column("dan_type", Integer, server_default="0"),
    Column("dan_level", Integer, server_default="0"),
    Column("title_0", Integer, server_default="0"),
    Column("title_1", Integer, server_default="0"),
    Column("title_2", Integer, server_default="0"),
    Column("rating", Integer, server_default="0"),
    Column("vip_expire_time", TIMESTAMP),
    Column("always_vip", Boolean, server_default="0"),
    Column("login_count", Integer, server_default="0"),
    Column("login_count_consec", Integer, server_default="0"),
    Column("login_count_days", Integer, server_default="0"),
    Column("login_count_days_consec", Integer, server_default="0"),
    Column("login_count_today", Integer, server_default="0"),
    Column("playcount_single", Integer, server_default="0"),
    Column("playcount_multi_vs", Integer, server_default="0"),
    Column("playcount_multi_coop", Integer, server_default="0"),
    Column("playcount_stageup", Integer, server_default="0"),
    Column("friend_view_1", Integer),
    Column("friend_view_2", Integer),
    Column("friend_view_3", Integer),
    Column("last_game_ver", String(50)),
    Column("last_song_id", Integer, server_default="0"),
    Column("last_song_difficulty", Integer, server_default="0"),
    Column("last_folder_order", Integer, server_default="0"),
    Column("last_folder_id", Integer, server_default="0"),
    Column("last_song_order", Integer, server_default="0"),
    Column("last_login_date", TIMESTAMP, server_default=func.now()),
    Column("gate_tutorial_flags", JSON),
    UniqueConstraint("user", "version", name="wacca_profile_uk"),
    mysql_charset="utf8mb4",
)

option = Table(
    "wacca_option",
    metadata,
    Column("id", Integer, primary_key=True, nullable=False),
    Column(
        "user",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column("opt_id", Integer, nullable=False),
    Column("value", Integer, nullable=False),
    UniqueConstraint("user", "opt_id", name="wacca_option_uk"),
)

bingo = Table(
    "wacca_bingo",
    metadata,
    Column(
        "user",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        primary_key=True,
        nullable=False,
    ),
    Column("page_number", Integer, nullable=False),
    Column("page_progress", JSON, nullable=False),
    UniqueConstraint("user", "page_number", name="wacca_bingo_uk"),
    mysql_charset="utf8mb4",
)

friend = Table(
    "wacca_friend",
    metadata,
    Column(
        "profile_sender",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column(
        "profile_reciever",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column("is_accepted", Boolean, server_default="0"),
    PrimaryKeyConstraint("profile_sender", "profile_reciever", name="arcade_owner_pk"),
    mysql_charset="utf8mb4",
)

favorite = Table(
    "wacca_favorite_song",
    metadata,
    Column("id", Integer, primary_key=True, nullable=False),
    Column(
        "user",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column("song_id", Integer, nullable=False),
    UniqueConstraint("user", "song_id", name="wacca_favorite_song_uk"),
    mysql_charset="utf8mb4",
)

gate = Table(
    "wacca_gate",
    metadata,
    Column("id", Integer, primary_key=True, nullable=False),
    Column(
        "user",
        ForeignKey("aime_user.id", ondelete="cascade", onupdate="cascade"),
        nullable=False,
    ),
    Column("gate_id", Integer, nullable=False),
    Column("page", Integer, nullable=False, server_default="0"),
    Column("progress", Integer, nullable=False, server_default="0"),
    Column("loops", Integer, nullable=False, server_default="0"),
    Column("last_used", TIMESTAMP, nullable=False, server_default=func.now()),
    Column("mission_flag", Integer, nullable=False, server_default="0"),
    Column("total_points", Integer, nullable=False, server_default="0"),
    UniqueConstraint("user", "gate_id", name="wacca_gate_uk"),
)


class WaccaProfileData(BaseData):
    def create_profile(
        self, aime_id: int, username: str, version: int
    ) -> Optional[int]:
        """
        Given a game version, aime id, and username, create a profile and return it's ID
        """
        sql = insert(profile).values(user=aime_id, username=username, version=version)

        conflict = sql.on_duplicate_key_update(username=sql.inserted.username)

        result = self.execute(conflict)
        if result is None:
            self.logger.error(
                f"{__name__} Failed to insert wacca profile! aime id: {aime_id} username: {username}"
            )
            return None
        return result.lastrowid

    def update_profile_playtype(
        self, profile_id: int, play_type: int, game_version: str
    ) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            playcount_single=profile.c.playcount_single + 1
            if play_type == 1
            else profile.c.playcount_single,
            playcount_multi_vs=profile.c.playcount_multi_vs + 1
            if play_type == 2
            else profile.c.playcount_multi_vs,
            playcount_multi_coop=profile.c.playcount_multi_coop + 1
            if play_type == 3
            else profile.c.playcount_multi_coop,
            playcount_stageup=profile.c.playcount_stageup + 1
            if play_type == 4
            else profile.c.playcount_stageup,
            last_game_ver=game_version,
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"update_profile: failed to update profile! profile: {profile_id}"
            )
        return None

    def update_profile_lastplayed(
        self,
        profile_id: int,
        last_song_id: int,
        last_song_difficulty: int,
        last_folder_order: int,
        last_folder_id: int,
        last_song_order: int,
    ) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            last_song_id=last_song_id,
            last_song_difficulty=last_song_difficulty,
            last_folder_order=last_folder_order,
            last_folder_id=last_folder_id,
            last_song_order=last_song_order,
        )
        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"update_profile_lastplayed: failed to update profile! profile: {profile_id}"
            )
        return None

    def update_profile_dan(
        self, profile_id: int, dan_level: int, dan_type: int
    ) -> Optional[int]:
        sql = profile.update(profile.c.id == profile_id).values(
            dan_level=dan_level, dan_type=dan_type
        )

        result = self.execute(sql)
        if result is None:
            self.logger.warn(
                f"update_profile_dan: Failed to update! profile {profile_id}"
            )
            return None
        return result.lastrowid

    def get_profile(self, profile_id: int = 0, aime_id: int = None) -> Optional[Row]:
        """
        Given a game version and either a profile or aime id, return the profile
        """
        if aime_id is not None:
            sql = profile.select(profile.c.user == aime_id)
        elif profile_id > 0:
            sql = profile.select(profile.c.id == profile_id)
        else:
            self.logger.error(
                f"get_profile: Bad arguments!! profile_id {profile_id} aime_id {aime_id}"
            )
            return None

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchone()

    def get_options(self, user_id: int, option_id: int = None) -> Optional[List[Row]]:
        """
        Get a specific user option for a profile, or all of them if none specified
        """
        sql = option.select(
            and_(
                option.c.user == user_id,
                option.c.opt_id == option_id if option_id is not None else True,
            )
        )

        result = self.execute(sql)
        if result is None:
            return None
        if option_id is not None:
            return result.fetchone()
        else:
            return result.fetchall()

    def update_option(self, user_id: int, option_id: int, value: int) -> Optional[int]:
        sql = insert(option).values(user=user_id, opt_id=option_id, value=value)

        conflict = sql.on_duplicate_key_update(value=value)

        result = self.execute(conflict)
        if result is None:
            self.logger.error(
                f"{__name__} failed to insert option! profile: {user_id}, option: {option_id}, value: {value}"
            )
            return None

        return result.lastrowid

    def add_favorite_song(self, user_id: int, song_id: int) -> Optional[int]:
        sql = favorite.insert().values(user=user_id, song_id=song_id)

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"{__name__} failed to insert favorite! profile: {user_id}, song_id: {song_id}"
            )
            return None
        return result.lastrowid

    def remove_favorite_song(self, user_id: int, song_id: int) -> None:
        sql = favorite.delete(
            and_(favorite.c.user == user_id, favorite.c.song_id == song_id)
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"{__name__} failed to remove favorite! profile: {user_id}, song_id: {song_id}"
            )
        return None

    def get_favorite_songs(self, user_id: int) -> Optional[List[Row]]:
        sql = favorite.select(favorite.c.user == user_id)

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchall()

    def get_gates(self, user_id: int) -> Optional[List[Row]]:
        sql = select(gate).where(gate.c.user == user_id)

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchall()

    def update_gate(
        self,
        user_id: int,
        gate_id: int,
        page: int,
        progress: int,
        loop: int,
        mission_flag: int,
        total_points: int,
    ) -> Optional[int]:
        sql = insert(gate).values(
            user=user_id,
            gate_id=gate_id,
            page=page,
            progress=progress,
            loops=loop,
            mission_flag=mission_flag,
            total_points=total_points,
        )

        conflict = sql.on_duplicate_key_update(
            page=sql.inserted.page,
            progress=sql.inserted.progress,
            loops=sql.inserted.loops,
            mission_flag=sql.inserted.mission_flag,
            total_points=sql.inserted.total_points,
        )

        result = self.execute(conflict)
        if result is None:
            self.logger.error(
                f"{__name__} failed to update gate! user: {user_id}, gate_id: {gate_id}"
            )
            return None
        return result.lastrowid

    def get_friends(self, user_id: int) -> Optional[List[Row]]:
        sql = friend.select(friend.c.profile_sender == user_id)

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchall()

    def profile_to_aime_user(self, profile_id: int) -> Optional[int]:
        sql = select(profile.c.user).where(profile.c.id == profile_id)

        result = self.execute(sql)
        if result is None:
            self.logger.info(
                f"profile_to_aime_user: No user found for profile {profile_id}"
            )
            return None

        this_profile = result.fetchone()
        if this_profile is None:
            self.logger.info(
                f"profile_to_aime_user: No user found for profile {profile_id}"
            )
            return None

        return this_profile["user"]

    def session_login(
        self, profile_id: int, is_new_day: bool, is_consec_day: bool
    ) -> None:
        # TODO: Reset consec days counter
        sql = profile.update(profile.c.id == profile_id).values(
            login_count=profile.c.login_count + 1,
            login_count_consec=profile.c.login_count_consec + 1,
            login_count_days=profile.c.login_count_days + 1
            if is_new_day
            else profile.c.login_count_days,
            login_count_days_consec=profile.c.login_count_days_consec + 1
            if is_new_day and is_consec_day
            else profile.c.login_count_days_consec,
            login_count_today=1 if is_new_day else profile.c.login_count_today + 1,
            last_login_date=func.now(),
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"session_login: failed to update profile! profile: {profile_id}"
            )
        return None

    def session_logout(self, profile_id: int) -> None:
        sql = profile.update(profile.c.id == id).values(login_count_consec=0)

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"{__name__} failed to update profile! profile: {profile_id}"
            )
        return None

    def add_xp(self, profile_id: int, xp: int) -> None:
        sql = profile.update(profile.c.id == profile_id).values(xp=profile.c.xp + xp)

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"add_xp: Failed to update profile! profile_id {profile_id} xp {xp}"
            )
        return None

    def add_wp(self, profile_id: int, wp: int) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            wp=profile.c.wp + wp,
            wp_total=profile.c.wp_total + wp,
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"add_wp: Failed to update profile! profile_id {profile_id} wp {wp}"
            )
        return None

    def spend_wp(self, profile_id: int, wp: int) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            wp=profile.c.wp - wp,
            wp_spent=profile.c.wp_spent + wp,
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"spend_wp: Failed to update profile! profile_id {profile_id} wp {wp}"
            )
        return None

    def activate_vip(self, profile_id: int, expire_time) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            vip_expire_time=expire_time
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"activate_vip: Failed to update profile! profile_id {profile_id} expire_time {expire_time}"
            )
        return None

    def update_user_rating(self, profile_id: int, new_rating: int) -> None:
        sql = profile.update(profile.c.id == profile_id).values(rating=new_rating)

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"update_user_rating: Failed to update profile! profile_id {profile_id} new_rating {new_rating}"
            )
        return None

    def update_bingo(self, aime_id: int, page: int, progress: int) -> Optional[int]:
        sql = insert(bingo).values(
            user=aime_id, page_number=page, page_progress=progress
        )

        conflict = sql.on_duplicate_key_update(page_number=page, page_progress=progress)

        result = self.execute(conflict)
        if result is None:
            self.logger.error(f"put_bingo: failed to update! aime_id: {aime_id}")
            return None
        return result.lastrowid

    def get_bingo(self, aime_id: int) -> Optional[List[Row]]:
        sql = select(bingo).where(bingo.c.user == aime_id)

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchone()

    def get_bingo_page(self, aime_id: int, page: Dict) -> Optional[List[Row]]:
        sql = select(bingo).where(
            and_(bingo.c.user == aime_id, bingo.c.page_number == page)
        )

        result = self.execute(sql)
        if result is None:
            return None
        return result.fetchone()

    def update_vip_time(self, profile_id: int, time_left) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            vip_expire_time=time_left
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(f"Failed to update VIP time for profile {profile_id}")

    def update_tutorial_flags(self, profile_id: int, flags: Dict) -> None:
        sql = profile.update(profile.c.id == profile_id).values(
            gate_tutorial_flags=flags
        )

        result = self.execute(sql)
        if result is None:
            self.logger.error(
                f"Failed to update tutorial flags for profile {profile_id}"
            )