damus

SupporterBadge.swift (8702B)

---

 //
 //  SupporterBadge.swift
 //  damus
 //
 //  Created by William Casarin on 2023-05-15.
 //
 
 import SwiftUI
 
 struct SupporterBadge: View {
     let percent: Int?
     let purple_account: DamusPurple.Account?
     let style: Style
     let text_color: Color
     var badge_variant: BadgeVariant {
         if purple_account?.attributes.contains(.memberForMoreThanOneYear) == true {
             return .oneYearSpecial
         }
         else {
             return .normal
         }
     }
     
     init(percent: Int?, purple_account: DamusPurple.Account? = nil, style: Style, text_color: Color = .secondary) {
         self.percent = percent
         self.purple_account = purple_account
         self.style = style
         self.text_color = text_color
     }
     
     let size: CGFloat = 17
     
     var body: some View {
         HStack {
             if let purple_account, purple_account.active == true {
                 HStack(spacing: 1) {
                     switch self.badge_variant {
                     case .normal:
                         StarShape()
                             .frame(width:size, height:size)
                             .foregroundStyle(GoldGradient)
                     case .oneYearSpecial:
                         DoubleStar(size: size)
                     }
                     
                     if self.style == .full,
                        let ordinal = self.purple_account?.ordinal() {
                         Text(ordinal)
                             .foregroundStyle(text_color)
                             .font(.caption)
                     }
                 }
             }
             else if let percent, percent < 100 {
                 Image("star.fill")
                     .resizable()
                     .frame(width:size, height:size)
                     .foregroundColor(support_level_color(percent))
             } else if let percent, percent == 100 {
                 Image("star.fill")
                     .resizable()
                     .frame(width:size, height:size)
                     .foregroundStyle(GoldGradient)
             }
         }
     }
     
     enum Style {
         case full       // Shows the entire badge with a purple subscriber number if present
         case compact    // Does not show purple subscriber number. Only shows the star (if applicable)
     }
     
     enum BadgeVariant {
         /// A normal badge that people are used to
         case normal
         /// A special badge for users who have been members for more than a year
         case oneYearSpecial
     }
 }
 
 
 struct StarShape: Shape {
     func path(in rect: CGRect) -> Path {
         var path = Path()
         let center = CGPoint(x: rect.midX, y: rect.midY)
         let radius: CGFloat = min(rect.width, rect.height) / 2
         let points = 5
         let adjustment: CGFloat = .pi / 2
         
         for i in 0..<points * 2 {
             let angle = (CGFloat(i) * .pi / CGFloat(points)) - adjustment
             let pointRadius = i % 2 == 0 ? radius : radius * 0.4
             let point = CGPoint(x: center.x + pointRadius * cos(angle), y: center.y + pointRadius * sin(angle))
             if i == 0 {
                 path.move(to: point)
             } else {
                 path.addLine(to: point)
             }
         }
         path.closeSubpath()
         return path
     }
 }
 
 struct DoubleStar: View {
     let size: CGFloat
     var starOffset: CGFloat = 5
     
     var body: some View {
         if #available(iOS 17.0, *) {
             DoubleStarShape(starOffset: starOffset)
                 .frame(width: size, height: size)
                 .foregroundStyle(GoldGradient)
                 .padding(.trailing, starOffset)
         } else {
             Fallback(size: size, starOffset: starOffset)
         }
     }
     
     @available(iOS 17.0, *)
     struct DoubleStarShape: Shape {
         var strokeSize: CGFloat = 3
         var starOffset: CGFloat
 
         func path(in rect: CGRect) -> Path {
             let normalSizedStarPath = StarShape().path(in: rect)
             let largerStarPath = StarShape().path(in: rect.insetBy(dx: -strokeSize, dy: -strokeSize))
             
             let finalPath = normalSizedStarPath
                 .subtracting(
                     largerStarPath.offsetBy(dx: starOffset, dy: 0)
                 )
                 .union(
                     normalSizedStarPath.offsetBy(dx: starOffset, dy: 0)
                 )
             
             return finalPath
         }
     }
     
     /// A fallback view for those who cannot run iOS 17
     struct Fallback: View {
         var size: CGFloat
         var starOffset: CGFloat
         
         var body: some View {
             HStack {
                 StarShape()
                     .frame(width: size, height: size)
                     .foregroundStyle(GoldGradient)
                 
                 StarShape()
                     .fill(GoldGradient)
                     .overlay(
                         StarShape()
                             .stroke(Color.damusAdaptableWhite, lineWidth: 1)
                     )
                     .frame(width: size + 1, height: size + 1)
                     .padding(.leading, -size - starOffset)
             }
             .padding(.trailing, -3)
         }
     }
 }
 
 
 
 func support_level_color(_ percent: Int) -> Color {
     if percent == 0 {
         return .gray
     }
     
     let percent_f = Double(percent) / 100.0
     let cutoff = 0.5
     let h = cutoff + (percent_f * cutoff); // Hue (note 0.2 = Green, see huge chart below)
     let s = 0.9; // Saturation
     let b = 0.9; // Brightness
     
     return Color(hue: h, saturation: s, brightness: b)
 }
 
 struct SupporterBadge_Previews: PreviewProvider {
     static func Level(_ p: Int) -> some View {
         HStack(alignment: .center) {
             SupporterBadge(percent: p, style: .full)
                 .frame(width: 50)
             Text(verbatim: p.formatted())
                 .frame(width: 50)
         }
     }
     
     static func Purple(_ subscriber_number: Int) -> some View {
         HStack(alignment: .center) {
             SupporterBadge(
                 percent: nil,
                 purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: subscriber_number, active: true, attributes: []),
                 style: .full
             )
                 .frame(width: 100)
         }
     }
     
     static var previews: some View {
         VStack(spacing: 0) {
             VStack(spacing: 0) {
                 Level(1)
                 Level(10)
                 Level(20)
                 Level(30)
                 Level(40)
                 Level(50)
             }
             Level(60)
             Level(70)
             Level(80)
             Level(90)
             Level(100)
             Purple(1)
             Purple(2)
             Purple(3)
             Purple(99)
             Purple(100)
             Purple(1971)
         }
     }
 }
 
 #Preview("1 yr badge") {
     VStack {
         HStack(alignment: .center) {
             SupporterBadge(
                 percent: nil,
                 purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: []),
                 style: .full
             )
                 .frame(width: 100)
         }
         
         HStack(alignment: .center) {
             SupporterBadge(
                 percent: nil,
                 purple_account: DamusPurple.Account(pubkey: test_pubkey, created_at: .now, expiry: .now.addingTimeInterval(10000), subscriber_number: 3, active: true, attributes: [.memberForMoreThanOneYear]),
                 style: .full
             )
                 .frame(width: 100)
         }
         
         Text(verbatim: "Double star (just shape itself, with alt background color, to show it adapts to background well)")
             .multilineTextAlignment(.center)
         
         if #available(iOS 17.0, *) {
             HStack(alignment: .center) {
                 DoubleStar.DoubleStarShape(starOffset: 5)
                     .frame(width: 17, height: 17)
                     .padding(.trailing, -8)
             }
             .background(Color.blue)
         }
         
         Text(verbatim: "Double star (fallback for iOS 16 and below)")
 
         HStack(alignment: .center) {
             DoubleStar.Fallback(size: 17, starOffset: 5)
         }
         
         Text(verbatim: "Double star (fallback for iOS 16 and below, with alt color limitation shown)")
             .multilineTextAlignment(.center)
         
         HStack(alignment: .center) {
             DoubleStar.Fallback(size: 17, starOffset: 5)
         }
         .background(Color.blue)
     }
 }