let customConfig = ChatConfig(
    chatPanel: ChatPanel(
        header: Header(title: "Testing..."),
        styling: Styling(
            primaryColor: .red,
            contrastColor: .blue,
            chatBubbles: ChatBubbles(
                userBackgroundColor: .brown,
                userTextColor: .purple,
                vaBackgroundColor: .green,
                vaTextColor: .yellow),
            buttons: Buttons(
                multiline: true,
                backgroundColor: .cyan,
                textColor: .magenta
            )
        ),
        settings: Settings(
            showLinkClickAsChatBubble: true
        )
    )
)

let vc = ChatViewController(backend: backend, customConfig: customConfig)
let navController = UINavigationController(rootViewController: vc)

present(navController, animated: true, completion: nil)

/// Font used for body text
public var bodyFont: UIFont = UIFont.preferredFont(forTextStyle: .body)

/// Font used for headlines
public var headlineFont: UIFont = UIFont.preferredFont(forTextStyle: .headline)

/// Font used for menu titles
public var menuItemFont: UIFont = UIFont.preferredFont(forTextStyle: .title3)

/// Font used for footnote sized strings (status messages, character count text etc.)
public var footnoteFont: UIFont = UIFont.preferredFont(forTextStyle: .footnote)

let customConfig = ChatConfig(
    chatPanel: ChatPanel(
        styling: Styling(
            fonts: Fonts(
                bodyFont: // My custom body font here
            )
        )
    )
)

backend.onReady { [weak self] (_, _) in
    // The backend has received a config and is now ready
    DispatchQueue.main.async {
        guard let self = self else { return }

        let avatarView = AgentAvatarView(backend: self.backend)
        avatarView.translatesAutoresizingMaskIntoConstraints = false

        self.view.addSubview(avatarView)

        let constraints = [
            self.view.trailingAnchor.constraint(equalTo: avatarView.trailingAnchor, constant: 20),
            self.view.safeAreaLayoutGuide.bottomAnchor.constraint(equalTo: avatarView.bottomAnchor, constant: 20)
        ]

        NSLayoutConstraint.activate(constraints)
    }
}

let chatViewController = ChatViewController(backend: backend)
let chatDialogNavController = UINavigationController(rootViewController: chatViewController)
tabBarController.viewControllers = [chatDialogNavController]

let backend = ChatBackend.shared
backend.onReady { [weak self] (_, _) in
    DispatchQueue.main.async {
        let chatViewController = ChatViewController(backend: backend)
        let chatDialogNavController = UINavigationController(rootViewController: chatViewController)
        self?.present(chatDialogNavController, animated: true)
    }
}

let chatViewController = ChatViewController(backend: backend)
chatViewController.chatResponseViewDataSource = self

public struct GenericCard: Decodable {
    
    public struct TextContent: Decodable {
        public let text: String
    }

    public struct Image: Decodable {
        public let alt: String?
        public let position: String?
        public let url: String?
    }

    public struct Link: Decodable {
        public let text: String?
        public let url: String
    }

    public let body: TextContent?
    public let heading: TextContent?
    public let image: Image?
    public let link: Link?
    public let template: String?

    enum CodingKeys: String, CodingKey {
        case body = "body"
        case heading = "heading"
        case image = "image"
        case link = "link"
        case template = "template"
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        body = try container.decodeIfPresent(TextContent.self, forKey: .body)
        heading = try container.decodeIfPresent(TextContent.self, forKey: .heading)
        image = try container.decodeIfPresent(Image.self, forKey: .image)
        link = try container.decodeIfPresent(Link.self, forKey: .link)
        template = try container.decodeIfPresent(String.self, forKey: .template)
    }
}

class MyClass: ChatResponseViewDataSource {
    func messageViewFor(element: Element) -> UIView? {
        switch element.type {
        case .json:
            guard let json = element.payload.json else { return nil }
            
            let decoder = JSONDecoder()
            do {
                let content = try decoder.decode(GenericCard.self, from: json)
                
                // Create a view tree that displays the data
                let view = ...
                return view
            } catch {
                // Handle JSON parsing error
            }
        default:
            return nil
    }
}

class CustomChatResponseView: ChatResponseView {
    override open func configureWith(response: Response, conversation: ConversationResult? = nil, animateElements: Bool = true, sender: ChatResponseViewDelegate?) {
          ...
    }
}

class MyClass: ChatViewControllerDelegate {

    /// Return a fully custom response view (must be a subclass of ChatResponseView
    func chatResponseView(backend: ChatBackend) -> ChatResponseView? {
        return CustomChatResponseView(backend: backend)
    }
    
    /// Return a custom subclass of a menu view controller if needed
    func menuViewController(backend: ChatBackend) -> MenuViewController? {
        return nil
    }

    /// Return a custom subclass of the conversation feedback view controller if needed
    func conversationFeedbackViewController(backend: ChatBackend) -> ConversationFeedbackViewController? {
        return nil
    }
}

BoostUIEvents.shared.addEventObserver(self) { event, detail in
   switch event {
   case .menuOpened:
       // Do something when the menu has opened
   default:
       break
   }
}

let backend = ChatBackend()
backend.domain = "sdk.boost.ai" // Replace with a possible custom domain

backend.addMessageObserver(self) { [weak self] (message, error) in
    DispatchQueue.main.async {
        // Handle the ApiMessage (Response.swift) received
    }
}

backend.addConfigObserver(self) { (config, error) in
    DispatchQueue.main.async {
        if let config = config {
            // Update styling based on the new config
        }
    }
}

backend.addEventObserver(self) { type, detail in
   switch type {
   case "myEventKey":
       // Handle emitted event with the key "myEventKey"
   default:
       break
   }
}

public enum Command: String, Codable {
    case
    START = "START",
    POST = "POST",
    DOWNLOAD = "DOWNLOAD",
    RESUME = "RESUME",
    DELETE = "DELETE",
    FEEDBACK = "FEEDBACK",
    TYPING = "TYPING",
    POLL = "POLL",
    POLLSTOP = "POLLSTOP",
    STOP = "STOP",
    LOGINEVENT = "LOGINEVENT",
    SMARTREPLY = "SMARTREPLY",
    HUMANCHATPOST = "HUMANCHATPOST",
    CONFIG = "CONFIG"
}

backend.start()
backend.start(CommandStart())
backend.start(CommandStart(filterValues: ['test']))

backend.stop()
backend.resume()
backend.delete()
backend.poll()
backend.pollStop()
backend.smartReply()
backend.humanChatPost()
backend.typing()
backend.conversationFeedback(CommandFeedback())
backend.download()
backend.loginEvent(CommandLoginEvent())

backend.actionButton(id: String)
backend.message(value: String)
backend.feedback(id: String, value: FeedbackValue)
backend.urlButton(id: String)
backend.sendFiles(files: [File])
backend.triggerAction(id: String)
backend.smartReply(value: String)
backend.humanChatPost(value: String)
backend.clientTyping(value: String) -> ClientTyping
backend.conversationFeedback(rating: Int, text: String?)
backend.loginEvent(userToken: String)

public protocol CommandProtocol: Encodable {
    var command: Command {get set}
}

backend.send(CommandStart())

backend.send(CommandStart()) { (apiMessage, error) in
    if let error = error {
        // Handle the error
        return
    }
    
    // Handle the ApiMessage
}

backend.isCertificatePinningEnabled = true