sodalive-backend-spring-boot/src/main/kotlin/kr/co/vividnext/sodalive/member/Member.kt

package kr.co.vividnext.sodalive.member

import kr.co.vividnext.sodalive.common.BaseEntity
import kr.co.vividnext.sodalive.explorer.GetExplorerSectionCreatorResponse
import kr.co.vividnext.sodalive.live.room.GenderRestriction
import kr.co.vividnext.sodalive.member.auth.Auth
import kr.co.vividnext.sodalive.member.following.CreatorFollowing
import kr.co.vividnext.sodalive.member.notification.MemberNotification
import kr.co.vividnext.sodalive.member.stipulation.StipulationAgree
import kr.co.vividnext.sodalive.member.tag.MemberCreatorTag
import java.time.LocalDateTime
import javax.persistence.CascadeType
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.EnumType
import javax.persistence.Enumerated
import javax.persistence.FetchType
import javax.persistence.OneToMany
import javax.persistence.OneToOne

@Entity
data class Member(
    var email: String? = null,
    var password: String,
    var nickname: String,
    var profileImage: String? = null,

    val kakaoId: Long? = null,
    val googleId: String? = null,
    val appleId: String? = null,
    val lineId: String? = null,

    @Enumerated(EnumType.STRING)
    val provider: MemberProvider = MemberProvider.EMAIL,

    @Enumerated(value = EnumType.STRING)
    var gender: Gender = Gender.NONE,

    @Enumerated(value = EnumType.STRING)
    var role: MemberRole = MemberRole.USER,

    @Column(nullable = true)
    var activePid: String? = null,

    @Column(nullable = true)
    var partnerExpirationDatetime: LocalDateTime? = null,

    var isVisibleDonationRank: Boolean = true,

    @Enumerated(value = EnumType.STRING)
    var donationRankingPeriod: DonationRankingPeriod? = DonationRankingPeriod.CUMULATIVE,

    var isActive: Boolean = true,

    var container: String = "web",

    // ISO 3166-1 alpha-2 국가 코드
    var countryCode: String? = null
) : BaseEntity() {
    @OneToMany(mappedBy = "member", cascade = [CascadeType.ALL])
    val stipulationAgrees: MutableList<StipulationAgree> = mutableListOf()

    @OneToMany(mappedBy = "member", cascade = [CascadeType.ALL], orphanRemoval = true)
    var tags: MutableList<MemberCreatorTag> = mutableListOf()

    @OneToMany(mappedBy = "creator")
    var follower: MutableList<CreatorFollowing> = mutableListOf()

    @OneToMany(mappedBy = "member", cascade = [CascadeType.ALL])
    val signOutReasons: MutableList<SignOut> = mutableListOf()

    @OneToOne(mappedBy = "member", fetch = FetchType.LAZY)
    var notification: MemberNotification? = null

    @OneToOne(mappedBy = "member", fetch = FetchType.LAZY)
    var auth: Auth? = null

    // 소개
    @Column(columnDefinition = "TEXT")
    var introduce = ""

    // SNS
    var instagramUrl = ""
    var youtubeUrl = ""
    var websiteUrl = ""
    var blogUrl = ""

    var pushToken: String? = null
    var adid: String? = null

    // 화폐
    var pgChargeCan: Int = 0
    var pgRewardCan: Int = 0
    var googleChargeCan: Int = 0
    var googleRewardCan: Int = 0
    var appleChargeCan: Int = 0
    var appleRewardCan: Int = 0

    fun getChargeCan(container: String): Int {
        return when (container) {
            "ios" -> appleChargeCan + pgChargeCan
            "aos" -> googleChargeCan + pgChargeCan
            else -> pgChargeCan
        }
    }

    fun getRewardCan(container: String): Int {
        return when (container) {
            "ios" -> appleRewardCan + pgRewardCan
            "aos" -> googleRewardCan + pgRewardCan
            else -> pgRewardCan
        }
    }

    fun charge(chargeCan: Int, rewardCan: Int, container: String) {
        when (container) {
            "ios" -> {
                appleChargeCan += chargeCan
                appleRewardCan += rewardCan
            }

            "aos" -> {
                googleChargeCan += chargeCan
                googleRewardCan += rewardCan
            }

            else -> {
                pgChargeCan += chargeCan
                pgRewardCan += rewardCan
            }
        }
    }

    fun toExplorerSectionCreator(
        imageHost: String,
        follow: Boolean = false,
        followerCount: Int = 0
    ): GetExplorerSectionCreatorResponse {
        return GetExplorerSectionCreatorResponse(
            id = id!!,
            nickname = nickname,
            tags = tags
                .filter { tag -> tag.tag.isActive }
                .map { tag -> tag.tag.tag }
                .joinToString(" ") { tag -> "#$tag" },
            profileImageUrl = if (profileImage != null) {
                "$imageHost/$profileImage"
            } else {
                "$imageHost/profile/default-profile.png"
            },
            followerCount = followerCount,
            follow = follow
        )
    }

    fun canEnter(restriction: GenderRestriction): Boolean {
        val effectiveGender = if (auth != null) {
            if (auth!!.gender == 1) Gender.MALE else Gender.FEMALE
        } else {
            gender
        }

        if (effectiveGender == Gender.NONE) return true

        return when (restriction) {
            GenderRestriction.ALL -> true
            GenderRestriction.MALE_ONLY -> effectiveGender == Gender.MALE
            GenderRestriction.FEMALE_ONLY -> effectiveGender == Gender.FEMALE
        }
    }
}

enum class Gender {
    MALE, FEMALE, NONE
}

enum class MemberRole {
    ADMIN, BOT, USER, CREATOR, AGENT
}

enum class MemberProvider {
    EMAIL, KAKAO, GOOGLE, APPLE, LINE
}

enum class DonationRankingPeriod {
    WEEKLY, CUMULATIVE
}