//
//  LKFAufenthaltResult.swift
//  lkfc
//
//  Created by Alexander Holzer on 20.08.18.
//  Copyright © 2018 Alexander Holzer. All rights reserved.
//

import Foundation
@_implementationOnly import LibLKF

public class LKFAufenthaltResult {
    
    weak var _aufenthalt: LKFAufenthalt?
    public let tp : Int
    public let lp : Int
    public let melzu : Int
    public let intzu : Int
    public let spez : Int
    public let scutk : Int
    public let sculk : Int
    public let sum : Int
    public let vdzu : Int
    
    public let ambSum : Int
    public let statSum : Int
    
    public let flag : Character
    
    public let gruppe : String
    public let knoten : String
    
    public let aufenthaltErrors : [LKFAufenthaltError]?
    public let categories : [LKFAufenthaltCategory]?
    public let abtbd : [Int]
    
    public let maxMELMELIndex : Int
    
    init (aufenthalt: LKFAufenthalt) {
        _aufenthalt = aufenthalt
        
        flag = LKFAufenthaltResult.getFieldValue(aufenthalt: aufenthalt, fieldIndex: 1).first ?? "-"
        aufenthaltErrors = LKFAufenthaltError.getErrors (aufenthalt:aufenthalt)
        let hasErrors = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 110)
        
        if hasErrors == 0 {
            melzu = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 32)
            intzu = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 31)
            spez = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 33)
            scutk = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 28)
            sculk = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 29)
            sum = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 44)
            tp = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 26)
            lp = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 27)
            ambSum = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 51)
            statSum = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 50)
            vdzu = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 30)
            maxMELMELIndex = LibLKF.lkf_auf_get_scorvalue(aufenthalt.ptr, 111)
        }
        else {
            melzu = 0
            intzu = 0
            spez = 0
            scutk = 0
            sculk = 0
            sum = 0
            tp = 0
            lp = 0
            ambSum = 0
            statSum = 0
            vdzu = 0
            maxMELMELIndex = 0
        }
        
        categories = LKFAufenthaltCategory.getCategories(aufenthalt: aufenthalt)
        
        let abtCount = aufenthalt.abtCount
        var abtBDarray = [Int]()
        let ptr = UnsafeMutablePointer<Int>.allocate(capacity: 1)
        for i in 0..<abtCount {
            LibLKF.lkf_auf_get_abtbd(aufenthalt.ptr, i, ptr)
            abtBDarray.append(ptr.pointee)
        }
        ptr.deallocate()
        
        abtbd = abtBDarray
        
        // LibLKF.lkf_auf_get_abtbd(_aufenthalt.ptr, 0, <#T##abtbd: UnsafeMutablePointer<Int>!##UnsafeMutablePointer<Int>!#>)
        
        gruppe = aufenthalt.getField(fieldNum: 21)
        knoten = aufenthalt.getField(fieldNum: 22)
    }
    
    static func getFieldValue(aufenthalt: LKFAufenthalt, fieldIndex: UInt32) -> String {
        let ptr = UnsafeMutablePointer<CChar>.allocate(capacity: 256)
        LibLKF.lkf_auf_get_fieldvalue(aufenthalt.ptr, fieldIndex, ptr, 256)
        let s = String(cString:ptr)
        ptr.deallocate()
        return s

    }
    
    func getFieldValue (fieldIndex: UInt32) -> String? {
        guard let aufenthalt = _aufenthalt else {
            return nil
        }
        return LKFAufenthaltResult.getFieldValue(aufenthalt:aufenthalt,fieldIndex:fieldIndex)
    }
    
    var x05 : String? {
        return _aufenthalt?.getResultLine()
    }
    
    var leistSum : Int {
        return lp + melzu + sculk
    }
    
    var tagSum : Int {
        return tp + scutk
    }
    
    public var gruppeknoten : String {
        if knoten.count > 0 && knoten != " " {
            return "\(gruppe)/\(knoten)"
        }
        return gruppe.trimmingCharacters(in: .whitespaces)
    }
}
