from fastapi import Request
import json
from process.logger import logger
import jwt
import datetime
import time

from firebase_admin import db as frd_db

KST = datetime.timezone(datetime.timedelta(hours=9))

# 파이어베이스 방 설정 업데이트
async def update_room_setting_info(room_seq, data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{room_seq}").child("roomInfo")
        ref.update({
            "room_title": data['room_title'],
            "room_intro": data['room_intro'],
            "open_yn": data['open_yn'],
            "running_time": data['running_time'],
            "number_of_people": data['number_of_people'],
            "score_open_range": data['score_open_range'],
        })
        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/score\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 업데이트
async def update_firebase_score(room_seq, user_seq, newScore):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userInfo").child(f"_{user_seq}")
        ref.update({"score": int(newScore)})
        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/score\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 방 생성
async def create_firebase_room(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}")

        # datetime 객체를 문자열로 변환
        initialData = {
            "roomInfo": {
                "room_type": data["room_type"],
                "master_user_seq": str(data["user_seq"]),
                "room_title": data["room_title"],
                "room_intro": data["room_intro"],
                "open_yn": data["open_yn"],
                "running_time": data["running_time"],
                "number_of_people": data["number_of_people"],
                "room_status": "WAIT",
                "number_of_teams": data["number_of_teams"],
                "team_name_list": [],
                "score_open_range": data["score_open_range"],
                "create_dt": f"{data['create_dt']}",
                "update_dt": f"{data['update_dt']}",
                "start_dt": f"{data['start_dt']}",
                "end_dt": f"{data['end_dt']}",
                "delete_yn": "N",
                "delete_dt": f"{data['delete_dt']}",
                "team_name_list": data['team_name_list']
            },
            "userInfo": {
                f"_{data['user_seq']}": {
                    "participant_type": data['user_info']['participant_type'],
                    "nickname": data['user_info']['nickname'],
                    "team_name": data['user_info']['team_name'],
                    "score": 0,
                    "profile_img": data['user_info']['profile_img'],
                    "department": data['user_info']['department'],
                    "introduce_myself": data['user_info']['introduce_myself'],
                    "ready_yn": "N",
                    "user_seq": str(data['user_seq']),
                    "connect_yn": "Y"
                }
            },
            "userList": {
                f"_{data['user_seq']}": True
            }
        }

        ref.set(initialData)

        return {
            "result": "OK",
            "msg": "방 생성 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/create/firebase/room\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "방 생성 실패"
        }


# 파이어베이스 방 설정정보 업데이트 초기 데이터 세팅
def set_room_setting_info(body):
    try:
        body = {
            "room_seq": body['room_seq'],
            "create_dt": body['create_dt'] if 'create_dt' in body else '',
            "delete_dt": body['delete_dt'] if 'delete_dt' in body else 'null',
            "delete_yn": body['delete_yn'] if 'delete_yn' in body else 'N',
            "end_dt": body['end_dt'] if 'end_dt' in body else 'null',
            "master_user_seq": str(body['master_user_seq']) if 'master_user_seq' in body else '',
            "number_of_people": body['number_of_people'] if 'number_of_people' in body else '',
            "number_of_teams": body['number_of_teams'] if 'number_of_teams' in body else '',
            "open_yn": body['open_yn'] if 'open_yn' in body else '',
            "room_intro": body['room_intro'] if 'room_intro' in body else '',
            "room_status": body['room_status'] if 'room_status' in body else '',
            "room_title": body['room_title'] if 'room_title' in body else '',
            "room_type": body['room_type'] if 'room_type' in body else '',
            "running_time": body['running_time'] if 'running_time' in body else '',
            "score_open_range": body['score_open_range'] if 'score_open_range' in body else '',
            "start_dt": body['start_dt'] if 'start_dt' in body else 'null',
            "update_dt": body['update_dt'] if 'update_dt' in body else f"{datetime.datetime.now(KST)}",
            "room_pw": body['room_pw'] if 'room_pw' in body else '',
        }
        return {
            "result": "OK",
            "data": body
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/room/setting/info\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "파이어베이스 업데이트 실패"
        }


# 파이어베이스 참가자 역할&팀 수정하기
async def update_participant_role(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userInfo").child(f"_{data['target_user_seq']}")
        ref.update({
            "participant_type": data['participant_type'], 
            "team_name": data['team_name'] if data['room_type_name'] == 'team' or data['room_type_name'] == 'TEAM' else 'PRIVATE'
        })
        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/user/role\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 팀명 수정하기
async def update_team_name(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("roomInfo").child("team_name_list")
        
        # 기존 team_name_list 가져오기
        current_team_names = ref.get()
        if current_team_names:
            # 팀 이름을 쉼표로 분리
            team_names = current_team_names.split(',')
            # before_team_name을 after_team_name으로 대체
            team_names = [data['after_team_name'] if name == data['before_team_name'] else name for name in team_names]
            # 다시 쉼표로 조인
            updated_team_names = ','.join(team_names)
        else:
            return {
                "result": "FAIL",
                "msg": "업데이트 실패"
            }
        
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("roomInfo")

        # 업데이트
        ref.update({
            "team_name_list": updated_team_names
        })

        # 유저의 팀명 수정
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userInfo")
        # 이전 팀명을 갖고있는 유저 확인
        user_list = ref.get()
        for user_seq, user_info in user_list.items():
            if user_info['team_name'] == data['before_team_name']:
                user_info['team_name'] = data['after_team_name']
                ref.update({
                    f"{user_seq}": user_info
                })

        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/team/name\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }
    
# 파이어베이스 팀명 확인
async def check_granted_team_name(room_seq):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userInfo")
        user_list = ref.get()
        for user_seq, user_info in user_list.items():
            if user_info['team_name'] == 'WAIT':
                return {
                    "result": "FAIL",
                    "msg": "대기중인 참가자가 있습니다."
                }
        return {
            "result": "OK",
            "msg": "대기중인 참가자가 없습니다."
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/check/granted/team/name\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "팀명 확인 실패"
        }

# 파이어베이스 방 상태 및 시작시간 업데이트
async def update_room_status_start_dt(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("roomInfo")
        ref.update({
            "room_status": data['room_status'],
            "start_dt": data['start_dt']
        })    
        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/room/status\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 방 상태 및 종료시간 업데이트
async def update_room_status_end_dt(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("roomInfo")
        ref.update({
            "room_status": data['room_status'], 
            "end_dt": data['end_dt']
        })
        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/room/status/end/dt\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 방 삭제
async def delete_room_score_frd(room_seq):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{room_seq}")
        ref.delete()
        return {
            "result": "OK",
            "msg": "삭제 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/delete/room/frd\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "삭제 실패"
        }


# 파이어베이스 나간 참여자 업데이트
async def update_exit_participant(data):
    try:
        user_seq = f"_{str(data['user_seq'])}"  # user_seq를 문자열로 변환
        if not user_seq:  # user_seq가 비어 있는지 확인
            logger.error("user_seq is empty or invalid.")
            return {
                "result": "FAIL",
                "msg": "user_seq is empty or invalid."
            }

        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userInfo")
        ref.child(user_seq).delete()  # user_seq가 올바른지 확인 후 삭제

        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userList")
        ref.child(user_seq).delete()  # user_seq가 올바른지 확인 후 삭제

        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/update/participant\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 방 입장하기
async def enter_room_user(room_seq, user_info):
    try:
        ref_list = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userList")
        ref_list.child(f"_{user_info['user_seq']}").set(True)

        # 재입장인지 확인
        ref_list = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userInfo")
        if ref_list.child(f"_{user_info['user_seq']}").get() is not None:
            return {
                "result": "OK",
                "msg": "재입장 성공"
            }

        ref_info = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userInfo").child(f"_{user_info['user_seq']}")
        ref_info.set(user_info)

        return {
            "result": "OK",
            "msg": "업데이트 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/enter/room/user\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }


# 파이어베이스 참여자 강퇴하기
async def kick_participant(data):
    try:
        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userList")
        ref.update({f"_{data['target_user_seq']}": False})

        ref = frd_db.reference("rooms").child(f"korea-{data['room_seq']}").child("userInfo")
        ref.child(f"_{data['target_user_seq']}").delete()

        return {
            "result": "OK",
            "msg": "강퇴 성공"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/kick/participant\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "강퇴 실패"
        }


# 파이어베이스 강퇴된 유저인지 확인
async def check_kick_user(user_seq, room_seq):
    try:
        user_seq = f"_{str(user_seq)}"  # user_seq를 문자열로 변환
        if not user_seq:  # user_seq가 비어 있는지 확인
            logger.error("user_seq is empty or invalid.")
            return {
                "result": "FAIL",
                "msg": "user_seq is empty or invalid."
            }

        ref = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userList").child(user_seq)
        user_info = ref.get()

        if user_info is None:
            return {
                "result": "FAIL",
                "msg": "강퇴된 유저가 아님"
            }

        if not user_info:
            return {
                "result": "OK",
                "msg": "강퇴된 유저"
            }
        else:
            return {
                "result": "FAIL",
                "msg": "강퇴된 유저가 아님"
            }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/check/kick/user\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "강퇴된 유저 확인 실패"
        }


# 파이어베이스 진행중 강제종료 된 유저인지 확인
async def check_force_exit_yn(user_seq, data):
    try:
        for room_seq, room_type_name, room_title in data:
            ref = frd_db.reference("rooms").child(f"korea-{room_seq}").child("userList").child(f"_{user_seq}")
            # True이면 강제종료 된 유저
            if ref.get() is True:
                return {
                    "result": "OK",
                    "msg": "강제종료 된 유저",
                    "room_seq": room_seq,
                    "room_type_name": room_type_name,
                    "room_title": room_title
                }
        return {
            "result": "FAIL",
            "msg": "강제종료 된 유저가 아님"
        }
    except Exception as e:
        logger.error(f"request error. URL: /room/score/check/force/exit/yn\nerror message: {e}")
        return {
            "result": "FAIL",
            "msg": "업데이트 실패"
        }