// 
// Decompiled by Procyon v0.6.0
// 

package org.jline.terminal.impl.ffm;

import org.jline.terminal.Size;
import org.jline.terminal.Attributes;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.IOException;
import org.jline.terminal.spi.SystemStream;
import org.jline.terminal.spi.TerminalProvider;
import java.io.FileDescriptor;
import org.jline.terminal.impl.AbstractPty;

class FfmNativePty extends AbstractPty
{
    private final int master;
    private final int slave;
    private final int slaveOut;
    private final String name;
    private final FileDescriptor masterFD;
    private final FileDescriptor slaveFD;
    private final FileDescriptor slaveOutFD;
    
    public FfmNativePty(final TerminalProvider provider, final SystemStream systemStream, final int master, final int slave, final String name) {
        this(provider, systemStream, master, AbstractPty.newDescriptor(master), slave, AbstractPty.newDescriptor(slave), slave, AbstractPty.newDescriptor(slave), name);
    }
    
    public FfmNativePty(final TerminalProvider provider, final SystemStream systemStream, final int master, final FileDescriptor masterFD, final int slave, final FileDescriptor slaveFD, final int slaveOut, final FileDescriptor slaveOutFD, final String name) {
        super(provider, systemStream);
        this.master = master;
        this.slave = slave;
        this.slaveOut = slaveOut;
        this.name = name;
        this.masterFD = masterFD;
        this.slaveFD = slaveFD;
        this.slaveOutFD = slaveOutFD;
    }
    
    @Override
    public void close() throws IOException {
        if (this.master > 0) {
            this.getMasterInput().close();
        }
        if (this.slave > 0) {
            this.getSlaveInput().close();
        }
    }
    
    public int getMaster() {
        return this.master;
    }
    
    public int getSlave() {
        return this.slave;
    }
    
    public int getSlaveOut() {
        return this.slaveOut;
    }
    
    public String getName() {
        return this.name;
    }
    
    public FileDescriptor getMasterFD() {
        return this.masterFD;
    }
    
    public FileDescriptor getSlaveFD() {
        return this.slaveFD;
    }
    
    public FileDescriptor getSlaveOutFD() {
        return this.slaveOutFD;
    }
    
    @Override
    public InputStream getMasterInput() {
        return new FileInputStream(this.getMasterFD());
    }
    
    @Override
    public OutputStream getMasterOutput() {
        return new FileOutputStream(this.getMasterFD());
    }
    
    @Override
    protected InputStream doGetSlaveInput() {
        return new FileInputStream(this.getSlaveFD());
    }
    
    @Override
    public OutputStream getSlaveOutput() {
        return new FileOutputStream(this.getSlaveOutFD());
    }
    
    @Override
    public Attributes getAttr() throws IOException {
        return CLibrary.getAttributes(this.slave);
    }
    
    @Override
    protected void doSetAttr(final Attributes attr) throws IOException {
        CLibrary.setAttributes(this.slave, attr);
    }
    
    @Override
    public Size getSize() throws IOException {
        return CLibrary.getTerminalSize(this.slave);
    }
    
    @Override
    public void setSize(final Size size) throws IOException {
        CLibrary.setTerminalSize(this.slave, size);
    }
    
    @Override
    public String toString() {
        return "FfmNativePty[" + this.getName();
    }
    
    public static boolean isPosixSystemStream(final SystemStream stream) {
        switch (stream) {
            case Input: {
                return CLibrary.isTty(0);
            }
            case Output: {
                return CLibrary.isTty(1);
            }
            case Error: {
                return CLibrary.isTty(2);
            }
            default: {
                throw new IllegalArgumentException();
            }
        }
    }
    
    public static String posixSystemStreamName(final SystemStream stream) {
        switch (stream) {
            case Input: {
                return CLibrary.ttyName(0);
            }
            case Output: {
                return CLibrary.ttyName(1);
            }
            case Error: {
                return CLibrary.ttyName(2);
            }
            default: {
                throw new IllegalArgumentException();
            }
        }
    }
    
    public static int systemStreamWidth(final SystemStream systemStream) {
        final int fd = (systemStream == SystemStream.Output) ? 1 : 2;
        return CLibrary.getTerminalSize(fd).getColumns();
    }
}