val jsonValue : String = "..."
val transformedJson = json(fromJson(jsonValue)) {
    /* operation1 */
    /* operation2 */
    /* operation3 */
    /* conditional block */
        /* operation4 */
}.getPrettyString() // Transformed output

fun main() {
    // JSON1 and JSON2 are both String variables 
    val transform = json(fromJson(JSON1)) {

        "person.id"         /= 100
        "person.firstName"  *= "$.first_name"
        "person.lastName"   *= "$.last_name"

        // We can using a nested json assignment instead of using the "." notation
        "person.meta" /= json {
            "information1" /= "ABC"
            "information2" /= "ABC2"
        }
        
        // We can assign a value from a lambda expression
        "person.maritalStatus" /= {
            if(sourceCtx().read("$.married")) 
                "married" 
            else 
                "unmarried"
        }

        "person.visited" *= {
            // We select only the country name from the visits array
            expression = "$.visits[*].country"
            processor = { countries ->
                // We don't allow duplications so we create a Set
                (countries as List<String>).toMutableSet()
            }
        }

        // We add a new country using the "[+]" notation
        "person.visited[+]" /= "Ireland"

        // We merge another array into the visited[] array
        "person.visited[++]" /= mutableListOf("Israel", "Japan")

        // We look into a secondary json source - JSON2
        // Assigning the citizenship array to a temporary path (person._tmp.array)
        "person._tmp" /= json(fromJson(JSON2)) {
            "array" *= "$.citizenship"
        }

        // We copy the content of temporary array into the path were we want to keep it
        "person._tmp.array" % "person.citizenships"

        // We remove the temporary path
        - "person._tmp"

        // We rename "citizenships" to "citizenship" because we don't like typos
        "person.citizenships" %= "person.citizenship"
    }

    println(transform)
}

package net.andreinc.mapneat.examples

import net.andreinc.mapneat.dsl.json

const val A_SRC_1 = """
{
    "id": 380557,
    "first_name": "Gary",
    "last_name": "Young"
}    
"""

const val A_SRC_2 = """
{
    "photo": "http://srcimg.com/100/150",
    "married": false
}
"""

fun main() {
    val transformed = json(A_SRC_1) {
        // Assigning a constant
        "user.user_name" /= "neo2020"

        // Assigning value from a lambda expression
        "user.first_name" /= { sourceCtx().read("$.first_name") }

        // Assigning value from another JSON source
        "more_info" /= json(A_SRC_2) {
            "married" /= { sourceCtx().read("$.married") }
        }

        // Assigning an inner JSON with the same source as the parent
        "more_info2" /= json {
            "last_name" /= { sourceCtx().read("$.last_name") }
        }
    }
    println(transformed)
}

fun main() {
    val transformed = json("{}") {
        println("Simple array creation:")
        "a" /= 1
        "b" /= 1
        println(this)

        println("Adds a new value in the array:")
        "a[+]" /= 2
        "b[+]" /= true
        println(this)

        println("Merge in an existing array:")
        "b[++]" /= arrayOf("a", "b", "c")
        println(this)
    }
}

package net.andreinc.mapneat.examples

import net.andreinc.mapneat.dsl.json
import java.time.LocalDate
import java.time.format.DateTimeFormatter

val JSON_VAL = """
{
  "id": 380557,
  "first_name": "Gary",
  "last_name": "Young",
  "photo": "http://srcimg.com/100/150",
  "married": false,
  "visits" : [ 
    {
        "country" : "Romania",
        "date" : "2020-10-10"
    },
    {
        "country" : "Romania",
        "date" : "2019-07-21"
    },
    {
        "country" : "Italy",
        "date" : "2019-12-21"
    },
    {
        "country" : "France",
        "date" : "2019-02-21"
    }
  ]
}
"""

fun main() {
    val transformed = json(JSON_VAL) {
        "user.name.first" *= "$.first_name"
        // We use an additional processor to capitalise the last Name
        "user.name.last" *= {
            expression = "$.last_name"
            processor = { (it as String).toUpperCase() }
        }
        // We add the photo directly into an array
        "user.photos[]" *= "$.photo"
        // We don't allow duplicates
        "user.visits.countries" *= {
            expression = "$.visits[*].country"
            processor = { (it as MutableList<String>).toSet().toMutableList() }
        }
        // We keep only the last visit
        "user.visits.lastVisit" *= {
            expression = "$.visits[*].date"
            processor = {
                (it as MutableList<String>)
                    .stream()
                    .map { LocalDate.parse(it, DateTimeFormatter.ISO_DATE) }
                    .max(LocalDate::compareTo)
                    .get()
                    .toString()
            }
        }
    }

    println(transformed)
}

"books" *=  {
                expression = "$.store.broken.path"
                lenient = true
            }

package net.andreinc.mapneat.examples

import net.andreinc.mapneat.dsl.json

fun main() {
    val transformed = json("{}") {
        "some.long.path" /= mutableListOf("A, B, C")
        "some.long.path" % "copy"
        println(this)
    }
}

package net.andreinc.mapneat.examples

import net.andreinc.mapneat.dsl.json

fun main() {
    json("{}") {
        "array" /= intArrayOf(1,2,3)
        "array" %= "a.b.c.d"
        println(this)
    }
}

package net.andreinc.mapneat.examples

import net.andreinc.mapneat.dsl.json

fun main() {
    json("{}") {
        "a.b.c" /= mutableListOf(1,2,3,4,true)
        "a.b.d" /= "a"
        // deletes the array from "a.b.c"
        - "a.b.c"
        println(this)
    }
}

@file : JvmName("Sample")

package kotlinPrograms

import net.andreinc.mapneat.dsl.json

fun personTransform(input: String) : String {
    return json(input) {
        "person.name" /= "Andrei"
        "person.age" /= 13
    }.getPrettyString()
}