Working with files/attachments

import SwiftUI
import Amplify

class SongViewModel: ObservableObject {

    @Published var currentSong: Song? = nil
    @Published var currentImage: UIImage? = nil
    @Published var isLoading: Bool = false

    // Create a song with an associated image
    func createSong(name: String, artCover: UIImage) async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }
                let song = Song(name: name)

        guard let imageData = artCover.pngData() else {
            print("Could not get data from image.")
            return
        }

        // Create the song record
        var createdSong = try await Amplify.API.mutate(request: .create(song)).get()
        let coverArtPath = "images/\(createdSong.id)"

        // Upload the art cover image
        _ = try await Amplify.Storage.uploadData(path: .fromString(coverArtPath), data: imageData).value

        // Update the song record with the image path
        createdSong.coverArtPath = coverArtPath
        let updatedSong = try await Amplify.API.mutate(request: .update(createdSong)).get()

        await setCurrentSong(updatedSong)
    }

    func getSongAndFile(currentSong: Song, imageData: Data) async throws {
        // Get the song record
        guard var song = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id)).get() else {
            print("Song may have been deleted, no song by id: ", currentSong.id)
            return
        }

        guard let coverArtPath = song.coverArtPath else {
            print("There is no cover art path to retrieve image")
            return
        }

        // Download the art cover
        let imageData = try await Amplify.Storage.downloadData(path: .fromString(coverArtPath)).value

        let image = UIImage(data: imageData)
    }

    // Add or update an image for an associated record
    func updateArtCover(artCover: UIImage) async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }

        guard var currentSong = currentSong else {
            print("There is no song to associated the image with. Create a Song first.")
            return
        }

        guard let imageData = artCover.pngData() else {
            print("Could not get data from UIImage.")
            return
        }

        let coverArtPath = "images/\(currentSong.id)"

        // Upload the new art image
        _ = try await Amplify.Storage.uploadData(path: .fromString(coverArtPath), data: imageData).value

        // Update the song record
        currentSong.coverArtPath = coverArtPath
        let updatedSong = try await Amplify.API.mutate(request: .update(currentSong)).get()

        await setCurrentSong(updatedSong)
    }

    func refreshSongAndArtCover() async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }
        guard let currentSong = currentSong else {
            print("There is no song to refresh the record and image. Create a song first.")
            return
        }
        await setCurrentSong(nil)
        await setCurrentImage(nil)

        // Get the song record
        guard let song = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id)).get() else {
            print("Song may have been deleted, no song by id: ", currentSong.id)
            return
        }

        guard let coverArtPath = song.coverArtPath else {
            print("Song does not contain cover art")
            await setCurrentSong(song)
            await setCurrentImage(nil)
            return
        }

        // Download the art cover
        let imageData = try await Amplify.Storage.downloadData(path: .fromString(coverArtPath)).value

        let image = UIImage(data: imageData)

        await setCurrentSong(song)
        await setCurrentImage(image)
    }

    func removeImageAssociationFromSong() async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }
        guard let currentSong = currentSong else {
            print("There is no song to remove art cover from it. Create a song first.")
            return
        }

        // Get the song record
        guard var song = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id)).get() else {
            print("Song may have been deleted, no song by id: ", currentSong.id)
            return
        }

        guard song.coverArtPath != nil else {
            print("There is no cover art path to remove image association")
            return
        }

        // Set the association to nil and update it
        song.coverArtPath = nil

        let updatedSong = try await Amplify.API.mutate(request: .update(song)).get()

        await setCurrentSong(updatedSong)
    }

    func removeImageAssociationAndDeleteImage() async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }
        guard let currentSong = currentSong else {
            print("There is no song to remove art cover from it. Create a song first.")
            return
        }

        // Get the song record
        guard var song = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id)).get() else {
            print("Song may have been deleted, no song by id: ", currentSong.id)
            return
        }

        guard let coverArtPath = song.coverArtPath else {
            print("There is no cover art path to remove image association")
            return
        }

        // Set the association to nil and update it
        song.coverArtPath = nil
        let updatedSong = try await Amplify.API.mutate(request: .update(song)).get()

        // Remove the image
        try await Amplify.Storage.remove(path: .fromString(coverArtPath))

        await setCurrentSong(updatedSong)
        await setCurrentImage(nil)
    }

    func deleteSongAndArtCover() async throws {
        await setIsLoading(true)
        defer {
            Task {
                await setIsLoading(false)
            }
        }
        guard let currentSong = currentSong else {
            print("There is no song to delete. Create a song first.")
            return
        }

        // Get the song record
        guard var song = try await Amplify.API.query(request: .get(Song.self, byId: currentSong.id)).get() else {
            print("Song may have been deleted, no song by id: ", currentSong.id)
            return
        }

        if let coverArt = song.coverArtPath {
            // Remove the image
            try await Amplify.Storage.remove(path: .fromString(coverArt))
        }

        // Delete the song record
        _ = try await Amplify.API.mutate(request: .delete(song)).get()

        await setCurrentSong(nil)
        await setCurrentImage(nil)
    }

    @MainActor
    func setCurrentSong(_ song: Song?) {
        self.currentSong = song
    }

    @MainActor
    func setCurrentImage(_ image: UIImage?) {
        self.currentImage = image
    }

    @MainActor
    func setIsLoading(_ isLoading: Bool) {
        self.isLoading = isLoading
    }
}

struct SongView: View {

    @State private var isImagePickerPresented = false
    @State private var songName: String = ""

    @StateObject var viewModel = SongViewModel()

    var body: some View {
        NavigationView {
            ZStack {
                VStack {
                    SongInformation()
                    DisplayImage()
                    OpenImagePickerButton()
                    SongNameTextField()
                    CreateOrUpdateSongButton()
                    AdditionalOperations()
                    Spacer()
                }
                .padding()
                .sheet(isPresented: $isImagePickerPresented) {
                    ImagePicker(selectedImage: $viewModel.currentImage)
                }
                VStack {
                    IsLoadingView()
                }
            }
            .navigationBarItems(trailing: SignOutButton())
        }
    }

    @ViewBuilder
    func SongInformation() -> some View {
        if let song = viewModel.currentSong {
            Text("Song Id: \(song.id)").font(.caption)
            if song.name != "" {
                Text("Song Name: \(song.name)").font(.caption)
            }
        }
    }

    @ViewBuilder
    func DisplayImage() -> some View {
        if let image = viewModel.currentImage {
            Image(uiImage: image)
                .resizable()
                .aspectRatio(contentMode: .fit)
        } else {
            Text("No Image Selected")
                .foregroundColor(.gray)
        }

    }

    func OpenImagePickerButton() -> some View {
        Button("Select \(viewModel.currentImage != nil ? "a new ": "" )song album cover") {
            isImagePickerPresented.toggle()
        }.buttonStyle(TappedButtonStyle())
    }

    @ViewBuilder
    func SongNameTextField() -> some View {
        TextField("\(viewModel.currentSong != nil ? "Update": "Enter") song name", text: $songName)
            .textFieldStyle(RoundedBorderTextFieldStyle())
            .multilineTextAlignment(.center)
    }

    @ViewBuilder
    func CreateOrUpdateSongButton() -> some View {
        if viewModel.currentSong == nil, let image = viewModel.currentImage {
            Button("Save") {
                Task {
                    try? await viewModel.createSong(name: songName,
                                                    artCover: image)
                }
            }
            .buttonStyle(TappedButtonStyle())
            .disabled(viewModel.isLoading)
        } else if viewModel.currentSong != nil, let image = viewModel.currentImage {
            Button("Update") {
                Task {
                    try? await viewModel.updateArtCover(artCover: image)
                }
            }
            .buttonStyle(TappedButtonStyle())
            .disabled(viewModel.isLoading)
        }
    }

    @ViewBuilder
    func AdditionalOperations() -> some View {
        if viewModel.currentSong != nil {
            VStack {
                Button("Refresh") {
                    Task {
                        try? await viewModel.refreshSongAndArtCover()
                    }
                }.buttonStyle(TappedButtonStyle())
                Button("Remove association from song") {
                    Task {
                        try? await viewModel.removeImageAssociationFromSong()
                    }
                }.buttonStyle(TappedButtonStyle())
                Button("Remove association and delete image") {
                    Task {
                        try? await viewModel.removeImageAssociationAndDeleteImage()
                    }
                }.buttonStyle(TappedButtonStyle())
                Button("Delete song and art cover") {
                    Task {
                        try? await viewModel.deleteSongAndArtCover()
                    }
                    songName = ""
                }.buttonStyle(TappedButtonStyle())
            }.disabled(viewModel.isLoading)
        }
    }

    @ViewBuilder
    func IsLoadingView() -> some View {
        if viewModel.isLoading {
            ZStack {
                DimmedBackgroundView()
                ProgressView()
            }
        }
    }
}

struct SongView_Previews: PreviewProvider {
    static var previews: some View {
        SongView()
    }
}