// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

/***************	Exceptions		***********/
public struct NSExceptionName : RawRepresentable, Equatable, Hashable {
    public private(set) var rawValue: String
    
    public init(_ rawValue: String) {
        self.rawValue = rawValue
    }
    
    public init(rawValue: String) {
        self.rawValue = rawValue
    }
    
    public var hashValue: Int {
        return self.rawValue.hashValue
    }
    
    public static func ==(_ lhs: NSExceptionName, _ rhs: NSExceptionName) -> Bool {
        return lhs.rawValue == rhs.rawValue
    }
}

extension NSExceptionName {
    public static let decimalNumberExactnessException = NSExceptionName(rawValue: "NSDecimalNumberExactnessException")
    public static let decimalNumberOverflowException = NSExceptionName(rawValue: "NSDecimalNumberOverflowException")
    public static let decimalNumberUnderflowException = NSExceptionName(rawValue: "NSDecimalNumberUnderflowException")
    public static let decimalNumberDivideByZeroException = NSExceptionName(rawValue: "NSDecimalNumberDivideByZeroException")
}

/***************	Rounding and Exception behavior		***********/

// Rounding policies :
// Original
//    value 1.2  1.21  1.25  1.35  1.27
// Plain    1.2  1.2   1.3   1.4   1.3
// Down     1.2  1.2   1.2   1.3   1.2
// Up       1.2  1.3   1.3   1.4   1.3
// Bankers  1.2  1.2   1.2   1.4   1.3

/***************	Type definitions		***********/
extension NSDecimalNumber {
    public enum RoundingMode : UInt {
        case plain // Round up on a tie
        case down // Always down == truncate
        case up // Always up
        case bankers // on a tie round so last digit is even
    }
    
    public enum CalculationError : UInt {
        case noError
        case lossOfPrecision // Result lost precision
        case underflow // Result became 0
        case overflow // Result exceeds possible representation
        case divideByZero
    }
}

public protocol NSDecimalNumberBehaviors {
    func roundingMode() -> NSDecimalNumber.RoundingMode
    func scale() -> Int16
}

// Receiver can raise, return a new value, or return nil to ignore the exception.

fileprivate func handle(_ error: NSDecimalNumber.CalculationError, _ handler: NSDecimalNumberBehaviors) {
    // handle the error condition, such as throwing an error for over/underflow
}

/***************	NSDecimalNumber: the class		***********/
open class NSDecimalNumber : NSNumber {

    fileprivate let decimal: Decimal
    public convenience init(mantissa: UInt64, exponent: Int16, isNegative: Bool) {
        var d = Decimal()
        d._exponent = Int32(exponent)
        d._isNegative = isNegative ? 1 : 0
        var man = mantissa
        d._mantissa.0 = UInt16(man & 0xffff)
        man >>= 4
        d._mantissa.1 = UInt16(man & 0xffff)
        man >>= 4
        d._mantissa.2 = UInt16(man & 0xffff)
        man >>= 4
        d._mantissa.3 = UInt16(man & 0xffff)
        d._length = 4
        d.trimTrailingZeros()
        // TODO more parts of the mantissa...
        self.init(decimal: d)
    }
    public init(decimal dcm: Decimal) {
        self.decimal = dcm
        super.init()
    }
    public convenience init(string numberValue: String?) {
        self.init(decimal: Decimal(string: numberValue ?? "") ?? Decimal.nan)
    }
    public convenience init(string numberValue: String?, locale: Any?) {
        self.init(decimal: Decimal(string: numberValue ?? "", locale: locale as? Locale) ?? Decimal.nan)
    }

    public required init?(coder: NSCoder) {
        guard coder.allowsKeyedCoding else {
            preconditionFailure("Unkeyed coding is unsupported.")
        }
        let exponent:Int32 = coder.decodeInt32(forKey: "NS.exponent")
        let length:UInt32 = UInt32(coder.decodeInt32(forKey: "NS.length"))
        let isNegative:UInt32 = UInt32(coder.decodeBool(forKey: "NS.negative") ? 1 : 0)
        let isCompact:UInt32 = UInt32(coder.decodeBool(forKey: "NS.compact") ? 1 : 0)
        // let byteOrder:UInt32 = UInt32(coder.decodeInt32(forKey: "NS.bo"))
        guard let mantissaData: Data = coder.decodeObject(forKey: "NS.mantissa") as? Data else {
            return nil // raise "Critical NSDecimalNumber archived data is missing"
        }
        guard mantissaData.count == Int(NSDecimalMaxSize * 2) else {
            return nil  // raise "Critical NSDecimalNumber archived data is wrong size"
        }
        // Byte order?
        let mantissa:(UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16, UInt16) = (
            UInt16(mantissaData[0]) << 8 & UInt16(mantissaData[1]),
            UInt16(mantissaData[2]) << 8 & UInt16(mantissaData[3]),
            UInt16(mantissaData[4]) << 8 & UInt16(mantissaData[5]),
            UInt16(mantissaData[6]) << 8 & UInt16(mantissaData[7]),
            UInt16(mantissaData[8]) << 8 & UInt16(mantissaData[9]),
            UInt16(mantissaData[10]) << 8 & UInt16(mantissaData[11]),
            UInt16(mantissaData[12]) << 8 & UInt16(mantissaData[13]),
            UInt16(mantissaData[14]) << 8 & UInt16(mantissaData[15])
        )
        self.decimal = Decimal(_exponent: exponent, _length: length, _isNegative: isNegative, _isCompact: isCompact, _reserved: 0, _mantissa: mantissa)
        super.init()
    }

    public required convenience init(floatLiteral value: Double) {
        self.init(decimal:Decimal(value))
    }

    public required convenience init(booleanLiteral value: Bool) {
        if value {
            self.init(integerLiteral: 1)
        } else {
            self.init(integerLiteral: 0)
        }
    }

    public required convenience init(integerLiteral value: Int) {
        self.init(decimal:Decimal(value))
    }
    
    public required convenience init(bytes buffer: UnsafeRawPointer, objCType type: UnsafePointer<Int8>) {
        NSRequiresConcreteImplementation()
    }
    
    open override func description(withLocale locale: Locale?) -> String {
        guard locale == nil else {
            fatalError("Locale not supported: \(locale!)")
        }
        return self.decimal.description
    }

    open class var zero: NSDecimalNumber {
        return NSDecimalNumber(integerLiteral: 0)
    }
    open class var one: NSDecimalNumber {
        return NSDecimalNumber(integerLiteral: 1)
    }
    open class var minimum: NSDecimalNumber {
        return NSDecimalNumber(decimal:Decimal.leastFiniteMagnitude)
    }
    open class var maximum: NSDecimalNumber {
        return NSDecimalNumber(decimal:Decimal.greatestFiniteMagnitude)

    }
    open class var notANumber: NSDecimalNumber {
        return NSDecimalNumber(decimal: Decimal.nan)
    }
    
    open func adding(_ other: NSDecimalNumber) -> NSDecimalNumber {
        return adding(other, withBehavior: nil)
    }
    open func adding(_ other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var left = self.decimal
        var right = other.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalAdd(&result, &left, &right, roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }

    open func subtracting(_ other: NSDecimalNumber) -> NSDecimalNumber {
        return subtracting(other, withBehavior: nil)
    }
    open func subtracting(_ other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var left = self.decimal
        var right = other.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalSubtract(&result, &left, &right, roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }
    open func multiplying(by other: NSDecimalNumber) -> NSDecimalNumber {
        return multiplying(by: other, withBehavior: nil)
    }
    open func multiplying(by other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var left = self.decimal
        var right = other.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalMultiply(&result, &left, &right, roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }
    
    open func dividing(by other: NSDecimalNumber) -> NSDecimalNumber {
        return dividing(by: other, withBehavior: nil)
    }
    open func dividing(by other: NSDecimalNumber, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var left = self.decimal
        var right = other.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalDivide(&result, &left, &right, roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }
    
    open func raising(toPower power: Int) -> NSDecimalNumber {
        return raising(toPower:power, withBehavior: nil)
    }
    open func raising(toPower power: Int, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var input = self.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalPower(&result, &input, power, roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }

    open func multiplying(byPowerOf10 power: Int16) -> NSDecimalNumber {
        return multiplying(byPowerOf10: power, withBehavior: nil)
    }
    open func multiplying(byPowerOf10 power: Int16, withBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var input = self.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let error = NSDecimalPower(&result, &input, Int(power), roundingMode)
        handle(error,behavior)
        return NSDecimalNumber(decimal: result)
    }
    
    // Round to the scale of the behavior.
    open func rounding(accordingToBehavior b: NSDecimalNumberBehaviors?) -> NSDecimalNumber {
        var result = Decimal()
        var input = self.decimal
        let behavior = b ?? NSDecimalNumber.defaultBehavior
        let roundingMode = behavior.roundingMode()
        let scale = behavior.scale()
        NSDecimalRound(&result, &input, Int(scale), roundingMode)
        return NSDecimalNumber(decimal: result)
    }
    
    // compare two NSDecimalNumbers
    open override func compare(_ decimalNumber: NSNumber) -> ComparisonResult {
        if let num = decimalNumber as? NSDecimalNumber {
            return decimal.compare(to:num.decimal)
        } else {
            return decimal.compare(to:Decimal(decimalNumber.doubleValue))
        }
    }

    open class var defaultBehavior: NSDecimalNumberBehaviors {
        return NSDecimalNumberHandler.defaultBehavior
    }
    // One behavior per thread - The default behavior is
    //   rounding mode: NSRoundPlain
    //   scale: No defined scale (full precision)
    //   ignore exactnessException
    //   raise on overflow, underflow and divide by zero.
    static let OBJC_TYPE = "d".utf8CString

    open override var objCType: UnsafePointer<Int8> {
        return NSDecimalNumber.OBJC_TYPE.withUnsafeBufferPointer{ $0.baseAddress! }
    }
    // return 'd' for double
    
    open override var int8Value: Int8 {
        return Int8(decimal.doubleValue)
    }
    open override var uint8Value: UInt8 {
        return UInt8(decimal.doubleValue)
    }
    open override var int16Value: Int16 {
        return Int16(decimal.doubleValue)
    }
    open override var uint16Value: UInt16 {
        return UInt16(decimal.doubleValue)
    }
    open override var int32Value: Int32 {
        return Int32(decimal.doubleValue)
    }
    open override var uint32Value: UInt32 {
        return UInt32(decimal.doubleValue)
    }
    open override var int64Value: Int64 {
        return Int64(decimal.doubleValue)
    }
    open override var uint64Value: UInt64 {
        return UInt64(decimal.doubleValue)
    }
    open override var floatValue: Float {
        return Float(decimal.doubleValue)
    }
    open override var doubleValue: Double {
        return decimal.doubleValue
    }
    open override var boolValue: Bool {
        return !decimal.isZero
    }
    open override var intValue: Int {
        return Int(decimal.doubleValue)
    }
    open override var uintValue: UInt {
        return UInt(decimal.doubleValue)
    }

    open override func isEqual(_ value: Any?) -> Bool {
        guard let other = value as? NSDecimalNumber else { return false }
        return self.decimal == other.decimal
    }

}

// return an approximate double value


/***********	A class for defining common behaviors		*******/
open class NSDecimalNumberHandler : NSObject, NSDecimalNumberBehaviors, NSCoding {

    static let defaultBehavior = NSDecimalNumberHandler()

    let _roundingMode: NSDecimalNumber.RoundingMode
    let _scale:Int16

    let _raiseOnExactness: Bool
    let _raiseOnOverflow: Bool
    let _raiseOnUnderflow: Bool
    let _raiseOnDivideByZero: Bool

    public override init() {
        _roundingMode = .plain
        _scale = Int16(NSDecimalNoScale)

        _raiseOnExactness = false
        _raiseOnOverflow = true
        _raiseOnUnderflow = true
        _raiseOnDivideByZero = true
    }
    public required init?(coder: NSCoder) {
        guard coder.allowsKeyedCoding else {
            preconditionFailure("Unkeyed coding is unsupported.")
        }
        _roundingMode = NSDecimalNumber.RoundingMode(rawValue: UInt(coder.decodeInteger(forKey: "NS.roundingMode")))!
        if coder.containsValue(forKey: "NS.scale") {
            _scale = Int16(coder.decodeInteger(forKey: "NS.scale"))
        } else {
            _scale = Int16(NSDecimalNoScale)
        }
        _raiseOnExactness = coder.decodeBool(forKey: "NS.raise.exactness")
        _raiseOnOverflow = coder.decodeBool(forKey: "NS.raise.overflow")
        _raiseOnUnderflow = coder.decodeBool(forKey: "NS.raise.underflow")
        _raiseOnDivideByZero = coder.decodeBool(forKey: "NS.raise.dividebyzero")
    }
    
    open func encode(with coder: NSCoder) {
        guard coder.allowsKeyedCoding else {
            preconditionFailure("Unkeyed coding is unsupported.")
        }
        if _roundingMode != .plain {
            coder.encode(Int(_roundingMode.rawValue), forKey: "NS.roundingmode")
        }
        if _scale != Int16(NSDecimalNoScale) {
            coder.encode(_scale, forKey:"NS.scale")
        }
        if _raiseOnExactness {
            coder.encode(_raiseOnExactness, forKey:"NS.raise.exactness")
        }
        if _raiseOnOverflow {
            coder.encode(_raiseOnOverflow, forKey:"NS.raise.overflow")
        }
        if _raiseOnUnderflow {
            coder.encode(_raiseOnUnderflow, forKey:"NS.raise.underflow")
        }
        if _raiseOnDivideByZero {
            coder.encode(_raiseOnDivideByZero, forKey:"NS.raise.dividebyzero")
        }
    }
    
    open class var `default`: NSDecimalNumberHandler {
        return defaultBehavior
    }
    // rounding mode: NSRoundPlain
    // scale: No defined scale (full precision)
    // ignore exactnessException (return nil)
    // raise on overflow, underflow and divide by zero.
    
    public init(roundingMode: NSDecimalNumber.RoundingMode, scale: Int16, raiseOnExactness exact: Bool, raiseOnOverflow overflow: Bool, raiseOnUnderflow underflow: Bool, raiseOnDivideByZero divideByZero: Bool) {
        _roundingMode = roundingMode
        _scale = scale
        _raiseOnExactness = exact
        _raiseOnOverflow = overflow
        _raiseOnUnderflow = underflow
        _raiseOnDivideByZero = divideByZero
    }
    
    open func roundingMode() -> NSDecimalNumber.RoundingMode {
        return _roundingMode
    }
    
    // The scale could return NoScale for no defined scale.
    open func scale() -> Int16 {
        return _scale
    }
}

extension NSNumber {
    
    public var decimalValue: Decimal {
        if let d = self as? NSDecimalNumber {
            return d.decimal
        } else {
            return Decimal(self.doubleValue)
        }
    }
}