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

package org.jline.terminal.impl;

import java.util.regex.Matcher;
import java.io.IOException;
import java.io.IOError;
import org.jline.utils.Curses;
import java.util.regex.Pattern;
import org.jline.utils.InfoCmp;
import org.jline.terminal.Cursor;
import java.util.function.IntConsumer;
import org.jline.terminal.Terminal;

public class CursorSupport
{
    public static Cursor getCursorPosition(final Terminal terminal, final IntConsumer discarded) {
        try {
            final String u6 = terminal.getStringCapability(InfoCmp.Capability.user6);
            final String u7 = terminal.getStringCapability(InfoCmp.Capability.user7);
            if (u6 == null || u7 == null) {
                return null;
            }
            boolean inc1 = false;
            final StringBuilder patb = new StringBuilder();
            int index = 0;
            while (index < u6.length()) {
                char ch;
                switch (ch = u6.charAt(index++)) {
                    case '\\': {
                        switch (u6.charAt(index++)) {
                            case 'E':
                            case 'e': {
                                patb.append("\\x1b");
                                continue;
                            }
                            default: {
                                throw new IllegalArgumentException();
                            }
                        }
                        break;
                    }
                    case '%': {
                        ch = u6.charAt(index++);
                        switch (ch) {
                            case '%': {
                                patb.append('%');
                                continue;
                            }
                            case 'i': {
                                inc1 = true;
                                continue;
                            }
                            case 'd': {
                                patb.append("([0-9]+)");
                                continue;
                            }
                            default: {
                                throw new IllegalArgumentException();
                            }
                        }
                        break;
                    }
                    default: {
                        switch (ch) {
                            case '[': {
                                patb.append('\\');
                                break;
                            }
                        }
                        patb.append(ch);
                        continue;
                    }
                }
            }
            final Pattern pattern = Pattern.compile(patb.toString());
            Curses.tputs(terminal.writer(), u7, new Object[0]);
            terminal.flush();
            final StringBuilder sb = new StringBuilder();
            int start = 0;
            while (true) {
                final int c = terminal.reader().read();
                if (c < 0) {
                    return null;
                }
                sb.append((char)c);
                final Matcher matcher = pattern.matcher(sb.substring());
                if (matcher.matches()) {
                    int y = Integer.parseInt(matcher.group(1));
                    int x = Integer.parseInt(matcher.group(2));
                    if (inc1) {
                        --x;
                        --y;
                    }
                    if (discarded != null) {
                        for (int i = 0; i < start; ++i) {
                            discarded.accept(sb.charAt());
                        }
                    }
                    return new Cursor(x, y);
                }
                if (matcher.hitEnd()) {
                    continue;
                }
                ++start;
            }
        }
        catch (final IOException e) {
            throw new IOError(e);
        }
    }
}