Sesame-iOS/Sesame-Watch Watch App/ContentView.swift

import SwiftUI
import CryptoKit

struct ContentView: View {
    
    @AppStorage("server")
    var serverPath: String = "https://christophhagen.de/sesame/"
    
    @AppStorage("localIP")
    var localAddress: String = "192.168.178.104/"

    @AppStorage("counter")
    var nextMessageCounter: Int = 0

    @AppStorage("compensate")
    var isCompensatingDaylightTime: Bool = false
    
    @AppStorage("local")
    private var useLocalConnection = false
    
    @AppStorage("deviceId")
    private var deviceId: Int = 0
    
    @EnvironmentObject
    var keyManager: KeyManagement
    
    @State
    var state: ClientState = .noKeyAvailable
    
    @State
    private var hasActiveRequest = false
    
    let server = Client()

    var buttonBackground: Color {
        state.allowsAction ?
            .white.opacity(0.2) :
            .black.opacity(0.2)
    }

    let buttonBorderWidth: CGFloat = 3

    var buttonColor: Color {
        state.allowsAction ? .white : .gray
    }
    
    private let sidePaddingRatio: CGFloat = 0.05
    private let buttonSizeRatio: CGFloat = 0.9

    private let smallButtonHeight: CGFloat = 50

    private let smallButtonWidth: CGFloat = 120

    private let smallButtonBorderWidth: CGFloat = 1
    
    var compensationTime: UInt32 {
        isCompensatingDaylightTime ? 3600 : 0
    }

    var isPerformingRequests: Bool {
        hasActiveRequest ||
        state == .waitingForResponse
    }
    
    var body: some View {
        VStack(alignment: .center) {
            Spacer()
            GeometryReader { geo in
                HStack(alignment: .center) {
                    Spacer()
                    let buttonWidth = min(geo.size.width, geo.size.height)
                    Text(state.actionText)
                        .frame(width: buttonWidth, height: buttonWidth)
                        .background(buttonBackground)
                        .cornerRadius(buttonWidth / 2)
                        .overlay(RoundedRectangle(cornerRadius: buttonWidth / 2)
                            .stroke(lineWidth: buttonBorderWidth).foregroundColor(buttonColor))
                        .foregroundColor(buttonColor)
                        .font(.title)
                        .disabled(!state.allowsAction)
                        .onTapGesture(perform: mainButtonPressed)
                    Spacer()
                }
            }
            Spacer()
        }
        .background(state.color)
        .animation(.easeInOut, value: state.color)
    }
    
    func mainButtonPressed() {
        guard let key = keyManager.get(.remoteKey),
              let token = keyManager.get(.authToken)?.data,
              let deviceId = UInt8(exactly: deviceId) else {
            return
        }
        let count = UInt32(nextMessageCounter)
        let sentTime = Date()
        // Add time to compensate that the device is using daylight savings time
        let content = Message.Content(
            time: sentTime.timestamp + compensationTime,
            id: count,
            device: deviceId)
        let message = content.authenticate(using: key)
        let historyItem = HistoryItem(sent: message.content, date: sentTime, local: useLocalConnection)
        state = .waitingForResponse
        print("Sending message \(count)")
        Task {
            let (newState, responseMessage) = await send(message, authToken: token)
            let receivedTime = Date.now
            //responseTime = receivedTime
            state = newState
            let finishedItem = historyItem.didReceive(response: newState, date: receivedTime, message: responseMessage?.content)
            guard let key = keyManager.get(.deviceKey) else {
                save(historyItem: finishedItem.notAuthenticated())
                return
            }
            guard let responseMessage else {
                save(historyItem: finishedItem)
                return
            }
            guard responseMessage.isValid(using: key) else {
                save(historyItem: finishedItem.invalidated())
                return
            }
            
            nextMessageCounter = Int(responseMessage.content.id)
            save(historyItem: finishedItem)
        }
    }
    
    private func send(_ message: Message, authToken: Data) async -> (state: ClientState, response: Message?) {
        if useLocalConnection {
            return await server.sendMessageOverLocalNetwork(message, server: localAddress)
        } else {
            return await server.send(message, server: serverPath, authToken: authToken)
        }
    }
    
    private func save(historyItem: HistoryItem) {
        
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
            .environmentObject(KeyManagement())
    }
}