AIEmoji/AIEmoji/Business/TSGenmojiVC/TSGenmojiGennerateVC/TSGenmojiGennerateViewModel.swift

//
//  Untitled.swift
//  AIEmoji
//
//  Created by 100Years on 2025/1/17.
//

import Combine
import Alamofire
enum TSProgressState  {
    case none
    case start
    case pending
    case progress(CGFloat)
    case progressString(String)
    case success(Any?)
    case failed(String)

    static func fromKeyValue(key string: String,value:String) -> TSProgressState {
        if string == "none" {
            return .none
        } else if string == "start" {
            return .start
        } else if string == "pending" {
            return .pending
        }else if string == "progress" {
            var progress = 0.0
            if let doubleValue = Float(value) {
                progress = CGFloat(doubleValue)
            }
            return .progress(progress)
        }else if string == "progressString" {
            return .progressString(value)
        }else if string == "success" {
            return .success(value)
        }else if string == "failed" {
            return .failed(value)
        }else{
            return .none
        }
    }
    
    var keyValue:(String,String){
        switch self {
        case .none:
            return ("none","")
        case .start:
            return ("start","")
        case .pending:
            return ("pending","")
        case .progress(let float):
            return ("progress",String(Float(float)))
        case .progressString(let string):
            return ("progressString",string)
        case .success(let string):
            if let string = string as? String{
                return ("success",string)
            }
            return ("success","")
        case .failed(let string):
            return ("failed",string)
        }
    }
    
    
    var isResult:Bool{
        switch self {
        case .none:
            return false
        case .start:
            return false
        case .pending:
            return false
        case .progress(_):
            return false
        case .progressString(_):
            return false
        case .success(_):
            return true
        case .failed(_):
            return true
        }
    }
    
    
    var reslutSuccess:Bool{
        switch self {
        case .success(_):
            return true
        case .failed(_):
            return false
        default:
            return false
        }
    }
    
    
    var reloadNewData:Bool{
        switch self {
        case .pending,.success(_),.failed(_):
            return true
        default:
            return false
        }
    }
}

class TSGenmojiGennerateViewModel {

    var creatRequest:Request?
    var queryRequest:Request?
    var stopNetwork = false
    
    @Published var stateDatauPblished:(TSProgressState,TSActionInfoModel?) = (TSProgressState.none,nil)
    var aiText:String = ""
    var generatingProgress = 0
    func creatImageEmoji(text:String) {
        stopNetwork = false
        aiText = text
        generatingProgress = 0
        stateDatauPblished = (.start,nil)
        stateDatauPblished = (.progressString(generating(progress: 0.0)),nil)
        creatRequest = TSNetworkShared.post(urlType: .imageEmoji,parameters: ["prompt":text,"device":getUserInfoJsonString()]) { [weak self] data,error in
            guard let self = self else { return }
            
            if let dataDict = kNetWorkCodeSuccess(data: data),
               let actionId = dataDict["actionId"] as? Int{
                if stopNetwork == false {
                    self.getActionInfo(action_id:actionId)
                }
            }else{
                self.stateDatauPblished = (.failed(error?.localizedDescription ?? ""),nil)
            }
        }
    }
    
    func getActionInfo(action_id:Int){
        queryRequest = TSNetworkShared.get(urlType: .actionInfo,parameters: ["action_id":action_id]) { [weak self] data,error in
            guard let self = self else { return }
            if let result = kNetWorkResultSuccess(data: data) {
                if let genmojiModel = TSActionInfoModel(JSON: result) {
                    switch genmojiModel.actionStatus {
                    case .success:
                        TSToastShared.hideLoading()
                        self.stateDatauPblished = (.success(nil),genmojiModel)
                        generatingProgress = 0
                    case .failed:
                        self.stateDatauPblished = (.failed(kNetWorkMessage(data: data) ?? ""),nil)
                        generatingProgress = 0
                    default:
                        stateDatauPblished = (.progressString(generating(progress: genmojiModel.percent)),nil)
                        if stopNetwork == false {
                            kDelayOnMainThread(1.0) {
                                self.getActionInfo(action_id: action_id)
                            }
                        }
                    }
                }
            }else{
                self.stateDatauPblished = (.failed(error?.localizedDescription ?? ""),nil)
            }
        }
    }
    
    
    func cancelAllRequest(){
        creatRequest?.cancel()
        queryRequest?.cancel()
        stopNetwork = true
    }
    
    func generating(progress:Float) -> String {

        //Generating 0%-100%
        var progressInt = Int(progress*100)
        if progressInt > 99 {
            progressInt = 99
        }
        
        generatingProgress = progressInt
        return "Generating".localized + " \(progressInt)%"
    }
}