             ].joined(separator: "\n")
         }
     }
+    
+    public struct ExtraInfo {
+        let expectType:Any
+        let actualType:Any
+        let value:Any
+        var description:String {
+            return [
+                "\tExpected Type : \(expectType)",
+                "\tActual Type : \(actualType)",
+                "\tActual Value : \(value)"
+            ].joined(separator: "\n")
+        }
+    }
+    
     case keyNotFound(baseInfo:BaseInfo)
     case nullValue(baseInfo:BaseInfo)
-    case typeMismatch(baseInfo:BaseInfo,expectType:Any,actualType:Any,value:Any)
+    case typeMismatch(baseInfo:BaseInfo,extraInfo:ExtraInfo)
     case specialCase(reason:String)
     
     static public func produceError<T> (targetType:T.Type, json:JSON, key:String) -> JSONDecodeError {

            return JSONDecodeError.nullValue(baseInfo: baseInfo)
        }
        
        return JSONDecodeError.typeMismatch(baseInfo: baseInfo, expectType: T.self, actualType: type(of:data),value: data)
    }
}


    public var description: String {
        switch self {
        case .keyNotFound(let baseInfo):
            return errorMessage(messageType: "Key Not Found::", baseInfo: baseInfo, extraInfo: nil)
        case .nullValue(let baseInfo):
            return errorMessage(messageType: "Null Value Found At:", baseInfo: baseInfo, extraInfo: nil)
        case .typeMismatch(let baseInfo, let extraInfo):
            return errorMessage(messageType: "Type Mismatch:", baseInfo: baseInfo, extraInfo: extraInfo)
        case .specialCase(let reason):
            return reason
        }
    }
    
    private func errorMessage(messageType: String, baseInfo: BaseInfo, extraInfo: ExtraInfo?) -> String {
        return [
            "",
            messageType,
            baseInfo.description,
            extraInfo?.description
        ].flatMap {$0}.joined(separator: "\n")
    }
}
