package runclass

object testLib {
    val socket: Library = makeLib()
}

fun makeLib(): Library {

    val serverPort = StateMachine("ServerPort")

    var inputStream = StateMachine(name = "InputStream")
    var specifiedInputStream = State(name = "SpecifiedInputStream", machine = inputStream)
    val closedInputStream = State(name = "closed", machine = inputStream)
    inputStream.ending = closedInputStream.name

    var outputStream = StateMachine(name = "OutputStream")
    var specifiedOutputStream = State(name = "SpecifiedOutputStream", machine = outputStream)
    val closedOutputStream = State(name = "closed", machine = outputStream)
    outputStream.ending = closedOutputStream.name

    var dataOutputStream = StateMachine(name = "DataOutputStream")
    var specifiedDataOutputStream = State(name = "SpecifiedDataOutputStream", machine = dataOutputStream)
    val closedDataOutputStream = State(name = "closed", machine = dataOutputStream)
    dataOutputStream.ending = closedDataOutputStream.name

    var inputStreamReader = StateMachine(name = "InputStreamReader")
    var specifiedInputStreamReader = State(name = "SpecifiedInputStreamReader", machine = inputStreamReader)
    val closedInputStreamReader = State(name = "closed", machine = inputStreamReader)
    inputStreamReader.ending = closedInputStreamReader.name

    var serverSocket = StateMachine(name = "ServerSocket")
    var specifiedServerSocket = State(name = "SpecifiedServerSocket", machine = serverSocket)
    val closedServerSocket = State(name = "closed", machine = serverSocket)
    serverSocket.ending = closedServerSocket.name

    var socket = StateMachine(name = "Socket")
    var specifiedSocket = State(name = "SpecifiedSocket", machine = socket)
    val closedSocket = State(name = "closed", machine = socket)
    socket.ending = closedSocket.name

    val bufferedReader = StateMachine(name = "BufferedReader")
    val specifiedBufferedReader = State(name = "SpecifiedBufferedReader", machine = bufferedReader)
    val closedBufferedReader = State(name = "closed", machine = bufferedReader)
    bufferedReader.ending = closedBufferedReader.name

    val printWriter = StateMachine(name = "PrintWriter")
    val specifiedPrintWriter = State(name = "SpecifiedPrintWriter", machine = printWriter)
    val closedPrintWriter = State(name = "closed", machine = printWriter)
    printWriter.ending = closedPrintWriter.name

    ConstructorEdge(
            machine = dataOutputStream,
            src = dataOutputStream.getConstructedState(),
            dst = specifiedBufferedReader,
            param = listOf(EntityParam(
                    machine = outputStream,
                    state = specifiedOutputStream
            )
            )
    )

    ConstructorEdge(
            machine = bufferedReader,
            src = bufferedReader.getConstructedState(),
            dst = specifiedBufferedReader,
            param = listOf(EntityParam(
                    machine = inputStreamReader,
                    state = specifiedInputStreamReader
            )
            )
    )

    ConstructorEdge(
            machine = printWriter,
            src = printWriter.getConstructedState(),
            dst = specifiedPrintWriter,
            param = listOf(EntityParam(
                    machine = outputStream,
                    state = specifiedOutputStream
            )
            )
    )

    ConstructorEdge(
            machine = inputStreamReader,
            src = inputStreamReader.getConstructedState(),
            dst = specifiedInputStreamReader,
            param = listOf(EntityParam(
                    machine = socket,
                    state = specifiedSocket
            )
            )
    )

    ConstructorEdge(
            machine = serverSocket,
            src = serverSocket.getConstructedState(),
            dst = specifiedServerSocket,
            param = listOf(EntityParam(
                    machine = serverPort
            )
            )
    )

    LinkedEdge(
            src = socket.getConstructedState(),
            //dst = specifiedSocket,
            dst = specifiedSocket,
            edge = CallEdge(
                    machine = serverSocket,
                    src = specifiedServerSocket,
                    dst = specifiedServerSocket,
                    methodName = "accept"
            )
    )

    AutoEdge(
            machine = socket,
            src = socket.getDefaultState(),
            dst = specifiedSocket
    )

    LinkedEdge(
            src = outputStream.getDefaultState(),
            dst = specifiedOutputStream,
            edge = CallEdge(
                    machine = socket,
                    src = specifiedSocket,
                    dst = specifiedSocket,
                    methodName = "getOutputStream"
            )
    )

    LinkedEdge(
            src = inputStream.getDefaultState(),
            dst = specifiedInputStream,
            edge = CallEdge(
                    machine = socket,
                    src = specifiedSocket,
                    dst = specifiedSocket,
                    methodName = "getInputStream"
            )
    )


    CallEdge(
            machine = bufferedReader,
            src = specifiedBufferedReader,
            dst = specifiedBufferedReader,
            methodName = "readLine"
    )

    CallEdge(
            machine = socket,
            src = socket.getConstructedState(),
            dst = socket.getConstructedState(),
            methodName = "getPort"
    )



    CallEdge(
            machine = socket,
            src = socket.getConstructedState(),
            dst = socket.getConstructedState(),
            methodName = "getOutputStream"
    )



    CallEdge(
            machine = serverSocket,
            src = specifiedServerSocket,
            dst = closedServerSocket,
            methodName = "close"
    )

    CallEdge(
            machine = printWriter,
            src = specifiedPrintWriter,
            dst = closedPrintWriter,
            methodName = "close"
    )

    CallEdge(
            machine = bufferedReader,
            src = specifiedBufferedReader,
            dst = closedBufferedReader,
            methodName = "close"
    )

    CallEdge(
            machine = dataOutputStream,
            src = specifiedDataOutputStream,
            dst = specifiedDataOutputStream,
            methodName = "write"
    )

    CallEdge(
            machine = dataOutputStream,
            src = specifiedDataOutputStream,
            dst = closedDataOutputStream,
            methodName = "close"
    )

    CallEdge(
            machine = dataOutputStream,
            src = specifiedDataOutputStream,
            dst = specifiedDataOutputStream,
            methodName = "flush"
    )

    CallEdge(
            machine = socket,
            src = specifiedSocket,
            dst = closedSocket,
            methodName = "close"
    )

    val fileName = StateMachine("fileName")

    var fileWriter = StateMachine(name = "FileWriter")
    val specifiedFileName = State(name = "SpecifiedFileName", machine = fileWriter)
    val closedFW = State(name = "closed", machine = fileWriter)
    fileWriter.ending = closedFW.name;

    ConstructorEdge(
            machine = fileWriter,
            src = fileWriter.getConstructedState(),
            dst = specifiedFileName,
            param = listOf(EntityParam(
                    machine = fileName
            )
            )
    )

    CallEdge(
            machine = fileWriter,
            src = specifiedFileName,
            dst = closedFW,
            methodName = "close"
    )


    val bufferedWriter = StateMachine(name = "BufferedWriter")
    val specifiedFile = State(name = "SpecifiedFile", machine = bufferedWriter)
    val closedBW = State(name = "closed", machine = bufferedWriter)
    bufferedWriter.ending = closedBW.name

    ConstructorEdge(
            machine = bufferedWriter,
            src = bufferedWriter.getConstructedState(),
            dst = specifiedFile,
            param = listOf(EntityParam(
                    machine = fileWriter,
                    state = specifiedFileName
            )
            )
    )

    CallEdge(
            machine = bufferedWriter,
            methodName = "write",
            src = specifiedFile,
            dst = specifiedFile
    )

    CallEdge(
            machine = bufferedWriter,
            src = specifiedFile,
            dst = closedBW,
            methodName = "close"
    )



    return Library(
            name = "java",
            stateMachines = listOf(serverPort, bufferedReader, inputStream, outputStream, printWriter, inputStreamReader, serverSocket, socket, fileWriter, fileName, bufferedWriter),
            machineTypes = mapOf(serverPort to "java.lang.String",
                    bufferedReader to "java.io.BufferedReader",
                    inputStream to "java.io.SocketInputStream",
                    outputStream to "java.io.OutputStream",
                    printWriter to "java.io.PrintWriter",
                    inputStreamReader to "java.io.InputStreamReader",
                    serverSocket to "java.net.ServerSocket",
                    socket to "java.net.Socket",
                    bufferedWriter to "java.io.BufferedWriter",
                    fileWriter to "java.io.FileWriter",
                    fileName to "String")
    )
}