SJR XML parser

package com.jachyhm.sjrregiojet

import android.util.Xml
import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserException
import java.io.IOException
import java.io.InputStream
import java.io.SerializablePermission
import java.util.*

val TRAIN_TYPES = arrayOf(
    "",
    "Ruš.",
    "Zvl."
)

val TRAIN_KINDS = arrayOf(
    "NEx",
    "Rn",
    "Pn",
    "Vn",
    "Mn",
    "Lv",
    "Vleč.",
    "LvZk",
    "Služ.",
    "EC",
    "IC",
    "Ex",
    "R",
    "Sp",
    "Os",
    "Sv",
    "EN"
)

data class Route(
    val track_sections: List<TrackSection>
)

data class TrackSection(
    val D3: Boolean,
    val timetable_entries: List<TimetableEntry>
)

data class TimetableEntry(
    val position: Float,
    val radioChannel: String,
    val maxSpeed: Int,
    val gps_loc: GPSLocation,
    val train_type: String,
    val train_kind: String,
    val train_number: Int,
    val point_name: String,
    val stopping: Boolean,
    val arrival: TimetableTime?,
    val departure: TimetableTime,
    val travel_time: TimetableTime,
    val brake_percents_id: Int?,
    val SR70: String,
    val symbol_notes: SymbolNotes,
    val noteIDs: MutableList<Int>,
    val trains: MutableList<Int>,
    val track: Int?
)

data class SymbolNotes(
    var col1: MutableList<Int> = mutableListOf(),
    var col2: MutableList<Int> = mutableListOf(),
    var col2a: MutableList<Int> = mutableListOf(),
    var col3: MutableList<Int> = mutableListOf(),
    var col4: MutableList<Int> = mutableListOf(),
    var col5: MutableList<Int> = mutableListOf(),
    var col6: MutableList<Int> = mutableListOf(),
    var col7: MutableList<Int> = mutableListOf(),
    var col8: MutableList<Int> = mutableListOf(),
    var col10: MutableList<Int> = mutableListOf()
)

data class GPSLocation(
    val lat: String,
    val lat_type: String,
    val lon: String,
    val lon_type: String
)

data class TimetableTime(
    val hours: Int,
    val minutes: Int,
    val seconds: Int
)

data class Instruction(
    val type: Int,
    val text: String
)

data class SharedAttributes(
    val train_types: List<String>,
    val train_kinds: List<String>,
    val train_loco: List<LocoAsset>,
    val notes: List<Note>,
    val brake_percents: MutableMap<Int,BrakePercent>
)

data class Note(
    val ID: Int,
    val station: String,
    val content: String,
    val pict_id: Int? = null,
    val train_number: Int? = null
)

data class BrakePercent(
    val speed: Int,
    val percent1: Int,
    val percent2: Int?
)

data class LocoAsset(
    val ID: Int,
    val name: String,
    val validity: CharArray
)

data class Timetable(
    val route: Route?,
    val instructions: List<Instruction>?,
    val shared_attributes: SharedAttributes?,
    val col2a: Boolean?,
    val col10: Boolean?
)

private fun makeTimetableTime(input: String?): TimetableTime? {
    if (input != null) {
        val s = input.split(":")
        return TimetableTime(s[0].toInt(), s[1].toInt(), s[2].toInt())
    }
    return null
}

data class TempNote(
    val pict_id: Int?,
    val station_name: String,
    val train_number: Int?
)

var notePics = mutableMapOf<Int, TempNote>()

var col2a = false
var col10 = false

class TimetableXmlParser {
    @Throws(XmlPullParserException::class, IOException::class)
    fun parse(inputStream: InputStream): Timetable? {
        inputStream.use { inputStream ->
            val parser: XmlPullParser = Xml.newPullParser()
            parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false)
            parser.setInput(inputStream, null)
            //parser.nextTag()
            return readXML(parser)
        }
    }

    @Throws(XmlPullParserException::class, IOException::class)
    private fun readXML(parser: XmlPullParser): Timetable? {
        //parser.require(XmlPullParser.START_TAG, null, "ETDTimetable")
        var timetable: Timetable? = null
        while (parser.next() != XmlPullParser.END_TAG && parser.eventType != XmlPullParser.END_DOCUMENT) {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            // Starts by looking for the entry tag
            if (parser.name == "ETDTimetable") {
                timetable = readETDT(parser)
            } else {
                skip(parser)
            }
        }
        return timetable
    }

    @Throws(XmlPullParserException::class, IOException::class)
    private fun readETDT(parser: XmlPullParser): Timetable? {
        parser.require(XmlPullParser.START_TAG, null, "ETDTimetable")
        var route: Route? = null
        var instructions: List<Instruction>? = null
        var shared_attributes: SharedAttributes? = null
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "ETDTimetable") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            when (parser.name) {
                "Route" -> route = readRoute(parser)
                "Instructions" -> instructions = readInstructions(parser)
                "SharedAttributes" -> shared_attributes = readSharedAttributes(parser)
                else -> skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "ETDTimetable")
        return Timetable(route, instructions, shared_attributes, col2a, col10)
    }

    // Processes Route tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readRoute(parser: XmlPullParser): Route? {
        parser.require(XmlPullParser.START_TAG, null, "Route")
        val track_sections = mutableListOf<TrackSection>()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "Route") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "TrackSection") {
                track_sections.add(readTrackSection(parser))
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "Route")
        return Route(track_sections)
    }

    // Processes TrackSection section tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readTrackSection(parser: XmlPullParser): TrackSection {
        parser.require(XmlPullParser.START_TAG, null, "TrackSection")
        var D3 = false
        val tt_entries = mutableListOf<TimetableEntry>()

        while (parser.next() != XmlPullParser.END_TAG || parser.name != "TrackSection") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "Track") {
                if (parser.getAttributeValue(null, "TrackType") == "primary") {
                    if (parser.getAttributeValue(null, "D3") == "true") {
                        D3 = true
                    }
                    while (parser.next() != XmlPullParser.END_TAG) {
                        if (parser.eventType != XmlPullParser.START_TAG) {
                            continue
                        }
                        if (parser.name == "TimetableEntry") {
                            tt_entries.add(readTimetableEntry(parser))
                        } else {
                            skip(parser)
                        }
                    }
                } else {
                    skip(parser)
                }
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "TrackSection")
        return TrackSection(D3, tt_entries)
    }

    // Processes TimetableEntry section tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readTimetableEntry(parser: XmlPullParser): TimetableEntry {
        parser.require(XmlPullParser.START_TAG, null, "TimetableEntry")
        var position = 0f
        var radioChannel = ""
        var maxSpeed = 0
        var gps_loc = GPSLocation("", "", "", "")
        var train_type = ""
        var train_kind = ""
        var train_number = 0
        var point_name = ""
        var stopping = false
        var arrival: TimetableTime? = null
        var departure = TimetableTime(0,0,0)
        var travel_time = TimetableTime(0,0,0)
        var brake_percents_id: Int? = null
        var SR70 = ""
        var symbol_notes = SymbolNotes()
        val noteIDs: MutableList<Int> = mutableListOf()
        val trains: MutableList<Int> = mutableListOf()
        var track: Int? = null

        while (parser.next() != XmlPullParser.END_TAG || parser.name != "TimetableEntry") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            when(parser.name) {
                "EntryHeader" -> {
                    position = parser.getAttributeValue(null, "kmPos").toFloat()
                    radioChannel = parser.getAttributeValue(null, "RadioChannel")
                    maxSpeed = parser.getAttributeValue(null, "Speed").toInt()
                    gps_loc = GPSLocation(
                        parser.getAttributeValue(null, "GPSLatitude"),
                        parser.getAttributeValue(null, "GPSLatitudeDir"),
                        parser.getAttributeValue(null, "GPSLongitude"),
                        parser.getAttributeValue(null, "GPSLongitudeDir")
                    )
                    train_type = TRAIN_TYPES[parser.getAttributeValue(null, "TrainTypeId").toInt()-1]
                    train_kind = TRAIN_KINDS[parser.getAttributeValue(null, "KindOfTrainId").toInt()-1]
                    train_number = parser.getAttributeValue(null, "TrainNumber").toInt()
                }

                "Station" -> {
                    point_name = parser.getAttributeValue(null, "Name")
                    if (parser.getAttributeValue(null, "TypePass") == "stop") {
                        stopping = true
                    }
                    arrival = makeTimetableTime(parser.getAttributeValue(null, "Arrival"))
                    val _departure = parser.getAttributeValue(null, "Departure")
                    if (_departure != null) {
                        departure = checkNotNull(makeTimetableTime(_departure))
                    }

                    val _travel_time = parser.getAttributeValue(null, "TimeTravel")
                    if (_travel_time != null) {
                        travel_time = checkNotNull(makeTimetableTime(_travel_time))
                    }

                    brake_percents_id = parser.getAttributeValue(null, "BrakePercentsId").toInt()
                    SR70 = parser.getAttributeValue(null, "SR70")

                    val _track = parser.getAttributeValue(null, "Track")
                    if(_track != null) {
                        col2a = true
                        track = _track.toInt()
                    }
                }

                "SymbolNotes" -> {
                    symbol_notes = readSymbolNotes(parser, point_name)
                }

                "Trains" -> {
                    while (parser.next() != XmlPullParser.END_TAG) {
                        if (parser.eventType != XmlPullParser.START_TAG) {
                            continue
                        }
                        if (parser.name == "Train") {
                            col10 = true
                            trains.add(parser.getAttributeValue(null, "TrainNumber").toInt())
                            if (parser.getAttributeValue(null, "NoteId") != null) {
                                notePics[parser.getAttributeValue(null, "NoteId").toInt()] = TempNote(null, point_name, parser.getAttributeValue(null, "TrainNumber").toInt())
                            }
                        }
                    }
                }

                else -> skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "TimetableEntry")
        return TimetableEntry(
            position,
            radioChannel,
            maxSpeed,
            gps_loc,
            train_type,
            train_kind,
            train_number,
            point_name,
            stopping,
            arrival,
            departure,
            travel_time,
            brake_percents_id,
            SR70,
            symbol_notes,
            noteIDs,
            trains,
            track
        )
    }

    // Processes EVId tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readSymbolNotes(parser: XmlPullParser, station_name: String): SymbolNotes {
        parser.require(XmlPullParser.START_TAG, null, "SymbolNotes")
        val symbol_notes = SymbolNotes()

        while (parser.next() != XmlPullParser.END_TAG || parser.name != "SymbolNotes") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "SymbolNote") {
                if (parser.getAttributeValue(null, "NoteId") != null) {
                    notePics[parser.getAttributeValue(null, "NoteId").toInt()] = TempNote(parser.getAttributeValue(null, "PictId").toInt(), station_name, null)
                }
                when(parser.getAttributeValue(null, "SymbolPosition")) {
                    "Col1" -> {
                        symbol_notes.col1.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col2" -> {
                        symbol_notes.col2.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col2a" -> {
                        symbol_notes.col2a.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col3" -> {
                        symbol_notes.col3.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col4" -> {
                        symbol_notes.col4.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col5" -> {
                        symbol_notes.col5.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col6" -> {
                        symbol_notes.col6.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col7" -> {
                        symbol_notes.col7.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col8" -> {
                        symbol_notes.col8.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                    "Col10" -> {
                        symbol_notes.col10.add(parser.getAttributeValue(null, "PictId").toInt())
                    }
                }
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "SymbolNotes")
        return symbol_notes
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readInstructions(parser: XmlPullParser): List<Instruction> {
        parser.require(XmlPullParser.START_TAG, null, "Instructions")
        val instructions: MutableList<Instruction> = mutableListOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "Instructions") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "Instruction") {
                instructions.add(Instruction(0, parser.getAttributeValue(null, "Text")))
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "Instructions")
        return instructions
    }

    // Processes summary tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readSharedAttributes(parser: XmlPullParser): SharedAttributes {
        parser.require(XmlPullParser.START_TAG, null, "SharedAttributes")
        var train_types: MutableList<String> = mutableListOf()
        var train_kinds: MutableList<String> = mutableListOf()
        var train_loco: MutableList<LocoAsset> = mutableListOf()
        var notes: MutableList<Note> = mutableListOf()
        var brake_percents: MutableMap<Int,BrakePercent> = mutableMapOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "SharedAttributes") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            when (parser.name) {
                "TrainTypes" -> {
                    train_types = readTrainTypes(parser)
                }
                "KindsOfTrain" -> {
                    train_kinds = readKindsOfTrain(parser)
                }
                "EVs" -> {
                    train_loco = readEVs(parser)
                }
                "Notes" -> {
                    notes = readNotes(parser)
                }
                "BrakePercentsRow" -> {
                    brake_percents = readBrakePercentsRow(parser)
                }
                else -> skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "SharedAttributes")
        return SharedAttributes(train_types, train_kinds, train_loco, notes, brake_percents)
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readTrainTypes(parser: XmlPullParser): MutableList<String> {
        parser.require(XmlPullParser.START_TAG, null, "TrainTypes")
        val train_types: MutableList<String> = mutableListOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "TrainTypes") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "TrainType") {
                train_types.add(TRAIN_TYPES[parser.getAttributeValue(null, "Id").toInt()-1])
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "TrainTypes")
        return train_types
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readKindsOfTrain(parser: XmlPullParser): MutableList<String> {
        parser.require(XmlPullParser.START_TAG, null, "KindsOfTrain")
        val kinds_of_train: MutableList<String> = mutableListOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "KindsOfTrain") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "KindOfTrain") {
                kinds_of_train.add(TRAIN_KINDS[parser.getAttributeValue(null, "Id").toInt()-1])
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "KindsOfTrain")
        return kinds_of_train
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readEVs(parser: XmlPullParser): MutableList<LocoAsset> {
        parser.require(XmlPullParser.START_TAG, null, "EVs")
        val evs: MutableList<LocoAsset> = mutableListOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "EVs") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "EV") {
                evs.add(LocoAsset(parser.getAttributeValue(null, "Id").toInt(), parser.getAttributeValue(null, "EVClass"), parser.getAttributeValue(null, "BitmapDays").toCharArray()))
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "EVs")
        return evs
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readNotes(parser: XmlPullParser): MutableList<Note> {
        parser.require(XmlPullParser.START_TAG, null, "Notes")
        val notes: MutableList<Note> = mutableListOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "Notes") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "Note") {
                val notePic = notePics[parser.getAttributeValue(null, "Id").toInt()]
                if (notePic != null) {
                    if (notePic.pict_id != null) {
                        notes.add(
                            Note(
                                parser.getAttributeValue(null, "Id").toInt(),
                                notePic.station_name,
                                parser.getAttributeValue(null, "Text"),
                                notePic.pict_id
                                )
                        )
                    } else {
                        notes.add(
                            Note(
                                parser.getAttributeValue(null, "Id").toInt(),
                                notePic.station_name,
                                parser.getAttributeValue(null, "Text"),
                                null,
                                notePic.train_number
                            )
                        )
                    }
                }
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "Notes")
        return notes
    }

    // Processes link tags in the feed.
    @Throws(IOException::class, XmlPullParserException::class)
    private fun readBrakePercentsRow(parser: XmlPullParser): MutableMap<Int,BrakePercent> {
        parser.require(XmlPullParser.START_TAG, null, "BrakePercentsRow")
        val brake_percents: MutableMap<Int,BrakePercent> = mutableMapOf()
        while (parser.next() != XmlPullParser.END_TAG || parser.name != "BrakePercentsRow") {
            if (parser.eventType != XmlPullParser.START_TAG) {
                continue
            }
            if (parser.name == "BrakePercentRow") {
                val _bp2 = parser.getAttributeValue(null, "BrakePercent2")
                var bp2: Int? = null
                if(_bp2 != null) {
                    bp2 = _bp2.toInt()
                }
                brake_percents[parser.getAttributeValue(null, "Id").toInt()] = (
                    BrakePercent(
                        parser.getAttributeValue(null, "TrainSpeed").toInt(),
                        parser.getAttributeValue(null, "BrakePercent1").toInt(),
                        bp2
                    )
                )
            } else {
                skip(parser)
            }
        }
        parser.require(XmlPullParser.END_TAG, null, "BrakePercentsRow")
        return brake_percents
    }

    @Throws(XmlPullParserException::class, IOException::class)
    private fun skip(parser: XmlPullParser) {
        if (parser.eventType != XmlPullParser.START_TAG) {
            throw IllegalStateException()
        }
        var depth = 1
        while (depth != 0) {
            when (parser.next()) {
                XmlPullParser.END_TAG -> depth--
                XmlPullParser.START_TAG -> depth++
            }
        }
    }
}