Proyectos de Subversion Iphone Microlearning - Nuevo Interface

//
//  CardGalleryView.swift
//  twogetskills
//
//  Created by Efrain Yanez Recanatini on 3/6/22.
//

import Foundation
import SwiftUI
import AVKit
import Network
import Alamofire
import SwiftyJSON
import TTGSnackbar

struct CardGalleryView: View {
    
    @EnvironmentObject private var networkMonitor : NetworkMonitor
    @EnvironmentObject private var appNavigation : AppNavigation
    @ObservedObject private var viewModel = GalleryCardViewModel()
    

    
    @State private var showGlobalAlert : Bool = false
    @State private var titleGlobalAlert : String = ""
    @State private var messageGlobalAlert : String = ""
    
    
    @State private var isDownloadInProgress = false
    @State private var isDownloadCompleted = false
    @State private var bytesDownloaded : Int64 = 0

    
    private var buttonShow : Bool = false
    private var buttonTitle : String = ""

    
    private let userUuid : String
    private var appData = AppData.sharedInstance

    
    init (slideUuid : String) {
        userUuid = appData.userUuid
        viewModel.fetch(slideUuid: slideUuid, userUuid: userUuid)

        self.buttonShow = false
        if self.viewModel.slide.type == Constants.SLIDE_TYPE_QUIZ  {
            self.buttonTitle = Config.LANG_BUTTON_LAUNCH_QUIZ
            self.buttonShow = true
        } else if self.viewModel.slide.type == Constants.SLIDE_TYPE_VIDEO {
            self.buttonTitle =  Config.LANG_BUTTON_LAUNCH_VIDEO_PLAYER
            self.buttonShow = true
        } else if self.viewModel.slide.type == Constants.SLIDE_TYPE_AUDIO   {
            self.buttonTitle = Config.LANG_BUTTON_LAUNCH_AUDIO_PLAYER
            self.buttonShow = true
        } else if self.viewModel.slide.type == Constants.SLIDE_TYPE_DOCUMENT {
            self.buttonTitle = Config.LANG_BUTTON_LAUNCH_VIEW_PDF
            self.buttonShow = true
            
        } else if self.viewModel.slide.type == Constants.SLIDE_TYPE_TEXT {
            self.buttonTitle = Config.LANG_BUTTON_LAUNCH_VIEW_TEXT
            self.buttonShow = true
        } else {
            self.buttonShow = false
        }
        
    }

    
    
    
    var body: some View {
        GeometryReader { geometry in
            let checkMarkX = (geometry.size.width - 50) / 2
            let checkMarkY = -1 * ((geometry.size.height - 50) / 2)
            
            let buttonX = (geometry.size.width - 180) / 2
           // let buttonY = (geometry.size.height - 80) / 2
            
            let buttonY = (geometry.size.height - 100) / 2
          
            ZStack {
                if self.isDownloadInProgress {
                    VStack {
                        ProgressView()
                        .progressViewStyle(CircularProgressViewStyle(tint: Color("color_progress_view_foreground")))
                        .scaleEffect(3, anchor: .center).zIndex(100000)
                        
                        Text(String( self.bytesDownloaded) + " bytes descargados").zIndex(100000)
                    }.background(Color("color_filter_background"))
                }
                
                if self.viewModel.slide.completed == 1  {
                    Image(uiImage: UIImage(named: "ic_slide_completado_checkmark") ?? UIImage()).offset(x: checkMarkX, y: checkMarkY).zIndex(10000)
                }
                
                if self.buttonShow {
                
                    Button(action: {
                        btnPlay()
                    }, label: {
                        Text(self.buttonTitle)
                            .font(Font.custom(Config.FONT_NAME_BOLD, size: Config.FONT_SIZE_BUTTONS))
                        .foregroundColor(Color("color_button_gallery_foreground"))
                       
                    })
              
                    .padding(.vertical, 15)
                    .padding(.horizontal, 10)
                    .background(Color("color_button_gallery_background"))
                    .cornerRadius(/*@START_MENU_TOKEN@*/3.0/*@END_MENU_TOKEN@*/)
                    .offset(x: buttonX, y: buttonY)
                    .zIndex(10000)
                }
                
                if (self.viewModel.progressCapsule >= 100 && self.viewModel.completedCapsule == 0)
                    || (self.viewModel.progressTopic >= 100 && self.viewModel.completedTopic == 0) {
                    Button(action: {
                        if self.viewModel.progressTopic >= 100 && self.viewModel.completedTopic == 0 {
                        
                            appNavigation.subpageActive = .finishtopic
                            
                        } else {
                            if self.viewModel.progressCapsule >= 100 && self.viewModel.completedCapsule == 0 {
                                appNavigation.subpageActive = .finishcapsule
                            }
                        }
                    }, label: {
                        Text(Config.LANG_BUTTON_FINISH_CAPSULE_OR_TOPIC)
                        .font(.callout)
                        .foregroundColor(.black)
                    })
                    .padding()
                    .background(Color("color_button_gallery_background"))
                    .cornerRadius(/*@START_MENU_TOKEN@*/3.0/*@END_MENU_TOKEN@*/)
                    .zIndex(10000)
                }
               
                VStack {
                
                    
                    
                    Spacer()
                    HStack {
                        if viewModel.slide.background.isEmpty && viewModel.slide.file.isEmpty {
                            Image(uiImage: UIImage(named: "logo") ?? UIImage())
                            .resizable()
                            .aspectRatio(contentMode: .fit)
                        } else {
                            CustomAsyncImage(
                                url: URL(string: self.viewModel.slide.type == Constants.SLIDE_TYPE_IMAGE ? self.viewModel.slide.file : self.viewModel.slide.background)!,
                                placeholder: {
                                    Spacer()
                                    Text(Config.LANG_COMMON_LOADING).font(.footnote).foregroundColor(.black)
                                    Spacer()
                                },
                                image: {
                                    Image(uiImage: $0).resizable()
                                }
                            )
                        }
                    }.padding(.horizontal, 5)

                    Spacer()
                }
               // .zIndex(500)
              
            }.onAppear {
                self.viewModel.fetchProgress(slideUuid: self.viewModel.slide.uuid, userUuid: self.userUuid)
            }
             .alert(isPresented: $showGlobalAlert) {
                Alert(
                    title: Text(self.titleGlobalAlert),
                    message: Text(self.messageGlobalAlert),
                    dismissButton: .default(Text(Config.LANG_COMMON_OK))
                )
            }
        }
    }
    
    private func btnPlay()
    {
        
        switch self.viewModel.slide.type
        {
            case Constants.SLIDE_TYPE_TEXT :
                appNavigation.pageActive = .webviewer
                break;
            
            case Constants.SLIDE_TYPE_QUIZ :
                let snackbar = TTGSnackbar(message: "Por implementar", duration: .long)
                snackbar.show()
                break;
            
            default :
                downloadFile();
                break;
        }
        
        
        
    }
    
    private func downloadFile()
    {
        if networkMonitor.status == .disconnected {
        
            self.titleGlobalAlert = Config.LANG_ERROR_NETWORK_TITLE
            self.messageGlobalAlert = Config.LANG_ERROR_NETWORK_MESSAGE_LONG
            self.showGlobalAlert  = true
            return
        }
        
        guard let url = URL(string: viewModel.slide.file) else {
            return
        }
        
        let arrayFullFilename = viewModel.slide.file.split(separator: "/")
        let filename  = String(arrayFullFilename[arrayFullFilename.count - 1])

        

        let headerSecurity = HeaderSecurity()
        
        let headers: HTTPHeaders = [
            .init(name: Constants.HTTP_HEADER_SECURITY_TOKEN, value: appData.deviceUuid),
            .init(name: Constants.HTTP_HEADER_SECURITY_SECRET, value: headerSecurity.secret),
            .init(name: Constants.HTTP_HEADER_SECURITY_CREATED, value: String(headerSecurity.created)),
            .init(name: Constants.HTTP_HEADER_SECURITY_RAND, value: String(headerSecurity.rand)),
            .accept(Constants.HTTP_HEADER_ACCEPT)
        ]
        
        AF.request(url, method: .get, headers: headers)
        .downloadProgress(closure : { (progress) in
            self.isDownloadInProgress = true
            self.bytesDownloaded = progress.completedUnitCount
            
        })
        .responseData{ (response) in
            self.isDownloadInProgress = false
                        
            if let data = response.data {
             let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
                let resourceURL = documentsURL.appendingPathComponent(filename)
                do {
                    try data.write(to: resourceURL)

                    appData.urlExternalDownloaded = resourceURL.absoluteString
                    appData.save()

                    switch self.viewModel.slide.type
                    {
                        case  Constants.SLIDE_TYPE_VIDEO  :
                           // AppDelegate.orientationLock = UIInterfaceOrientationMask.landscapeLeft
                           //UIDevice.current.setValue(UIInterfaceOrientation.landscapeLeft.rawValue, forKey: "orientation")
                          //UIViewController.attemptRotationToDeviceOrientation()
                            
                            
                            self.appNavigation.pageActive = .videoplayer
                            break
                   
                        case Constants.SLIDE_TYPE_AUDIO :
                           self.appNavigation.pageActive = .videoplayer
                            break
                       
                        default :
                            self.appNavigation.pageActive = .pdfviewer
                            break
                    }
                } catch {
                    self.titleGlobalAlert = Config.LANG_ERROR_COMMUNICATION_TITLE
                    self.messageGlobalAlert = Config.LANG_ERROR_COMMUNICATION_MESSAGE
                    self.showGlobalAlert  = true
                }
               
            }
        }
    }

}

struct CardGalleryView_Previews: PreviewProvider {
    static var previews: some View {
        CardGalleryView(slideUuid: "S123")
    }
    
}