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

package org.jline.reader.impl;

import org.jline.utils.WCWidth;
import org.jline.utils.AttributedStyle;
import org.jline.utils.AttributedStringBuilder;
import org.jline.utils.AttributedString;
import org.jline.reader.LineReader;
import java.util.regex.Pattern;
import org.jline.reader.Highlighter;

public class DefaultHighlighter implements Highlighter
{
    protected Pattern errorPattern;
    protected int errorIndex;
    
    public DefaultHighlighter() {
        this.errorIndex = -1;
    }
    
    @Override
    public void setErrorPattern(final Pattern errorPattern) {
        this.errorPattern = errorPattern;
    }
    
    @Override
    public void setErrorIndex(final int errorIndex) {
        this.errorIndex = errorIndex;
    }
    
    @Override
    public AttributedString highlight(final LineReader reader, final String buffer) {
        int underlineStart = -1;
        int underlineEnd = -1;
        int negativeStart = -1;
        int negativeEnd = -1;
        boolean first = true;
        final String search = reader.getSearchTerm();
        if (search != null && search.length() > 0) {
            underlineStart = buffer.indexOf(search);
            if (underlineStart >= 0) {
                underlineEnd = underlineStart + search.length() - 1;
            }
        }
        if (reader.getRegionActive() != LineReader.RegionType.NONE) {
            negativeStart = reader.getRegionMark();
            negativeEnd = reader.getBuffer().cursor();
            if (negativeStart > negativeEnd) {
                final int x = negativeEnd;
                negativeEnd = negativeStart;
                negativeStart = x;
            }
            if (reader.getRegionActive() == LineReader.RegionType.LINE) {
                while (negativeStart > 0 && reader.getBuffer().atChar(negativeStart - 1) != 10) {
                    --negativeStart;
                }
                while (negativeEnd < reader.getBuffer().length() - 1 && reader.getBuffer().atChar(negativeEnd + 1) != 10) {
                    ++negativeEnd;
                }
            }
        }
        final AttributedStringBuilder sb = new AttributedStringBuilder();
        this.commandStyle(reader, sb, true);
        for (int i = 0; i < buffer.length(); ++i) {
            if (i == underlineStart) {
                sb.style(AttributedStyle::underline);
            }
            if (i == negativeStart) {
                sb.style(AttributedStyle::inverse);
            }
            if (i == this.errorIndex) {
                sb.style(AttributedStyle::inverse);
            }
            final char c = buffer.charAt(i);
            if (first && Character.isSpaceChar(c)) {
                first = false;
                this.commandStyle(reader, sb, false);
            }
            if (c == '\t' || c == '\n') {
                sb.append(c);
            }
            else if (c < ' ') {
                sb.style(AttributedStyle::inverseNeg).append('^').append((char)(c + '@')).style(AttributedStyle::inverseNeg);
            }
            else {
                final int w = WCWidth.wcwidth(c);
                if (w > 0) {
                    sb.append(c);
                }
            }
            if (i == underlineEnd) {
                sb.style(AttributedStyle::underlineOff);
            }
            if (i == negativeEnd) {
                sb.style(AttributedStyle::inverseOff);
            }
            if (i == this.errorIndex) {
                sb.style(AttributedStyle::inverseOff);
            }
        }
        if (this.errorPattern != null) {
            sb.styleMatches(this.errorPattern, AttributedStyle.INVERSE);
        }
        return sb.toAttributedString();
    }
    
    protected void commandStyle(final LineReader reader, final AttributedStringBuilder sb, final boolean enable) {
    }
}