package silicondust;
/*-
 * ##########################################################################
 * TV H/W, EPGs, and Recording
 * $Id: HDHRTuner.java 5999 2020-05-18 16:41:28Z ball $
 * $HeadURL: svn+ssh://svn.hcf.dev/var/spool/scm/repository.svn/silicondust/trunk/src/main/java/silicondust/HDHRTuner.java $
 * %%
 * Copyright (C) 2013 - 2020 Allen D. Ball
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ##########################################################################
 */
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import java.util.zip.CRC32;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;

import static java.lang.String.format;
import static java.nio.ByteOrder.BIG_ENDIAN;
import static java.nio.ByteOrder.LITTLE_ENDIAN;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Arrays.asList;
import static org.apache.commons.lang3.StringUtils.SPACE;

/**
 * {@link.uri http://www.silicondust.com/ SiliconDust} HDHomeRun tuner.
 *
 * @author {@link.uri mailto:ball@hcf.dev Allen D. Ball}
 * @version $Revision: 5999 $
 */
public class HDHRTuner {

    /**
     * hdhomerun_pkt.h
     */
    private static final int
        DISCOVER_UDP_PORT = 65001,
        CONTROL_TCP_PORT = 65001;

    /**
     * hdhomerun_pkt.h
     */
    private static final int
        MAX_PACKET_SIZE = 1460,
        MAX_PAYLOAD_SIZE = 1452;

    /**
     * hdhomerun_pkt.h
     */
    private static final short
        TYPE_DISCOVER_REQ = 0x0002,
        TYPE_DISCOVER_RPY = 0x0003,
        TYPE_GETSET_REQ = 0x0004,
        TYPE_GETSET_RPY = 0x0005,
        TYPE_UPGRADE_REQ = 0x0006,
        TYPE_UPGRADE_RPY = 0x0007;

    /**
     * hdhomerun_pkt.h
     */
    private static final byte
        TAG_DEVICE_TYPE = 0x01,
        TAG_DEVICE_ID = 0x02,
        TAG_GETSET_NAME = 0x03,
        TAG_GETSET_VALUE = 0x04,
        TAG_GETSET_LOCKKEY = 0x15,
        TAG_ERROR_MESSAGE = 0x05,
        TAG_TUNER_COUNT = 0x10;

    /**
     * hdhomerun_pkt.h
     */
    private static final int
        DEVICE_TYPE_WILDCARD = 0xFFFFFFFF,
        DEVICE_TYPE_TUNER = 0x00000001;

    /**
     * hdhomerun_pkt.h
     */
    private static final int DEVICE_ID_WILDCARD = 0xFFFFFFFF;

    private static final String AT = "@";
    private static final String COLON = ":";
    private static final String EQUALS = "=";
    private static final String LB = "[";
    private static final String LF = "\n";
    private static final String RB = "]";
    private static final String SLASH = "/";

    private static final String AUTO = "auto";
    private static final String NONE = "none";

    /**
     * Static method to determine the HDHomeRun tuners on the network.
     *
     * @return  The {@link Map} of IDs and {@link HDHRTuner}s.
     */
    public static Map<Integer,HDHRTuner> discover() {
        HashMap<Integer,HDHRTuner> map = new HashMap<>();

        for (DiscoverReply reply :
                 new ArrayList<DiscoverReply>(thread().map().values())) {
            if (! map.containsKey(reply.getID())) {
                try {
                    map.put(reply.getID(), new HDHRTuner(reply));
                } catch (Exception exception) {
                }
            }

            if (! map.containsKey(reply.getID())) {
                thread().map().remove(reply.getInetAddress());
            }
        }

        return map;
    }

    private static DiscoveryThread thread = null;

    private static DiscoveryThread thread() {
        synchronized (HDHRTuner.class) {
            if (thread == null || (! thread.isAlive())) {
                thread = new DiscoveryThread();
                thread.start();

                try {
                    Thread.sleep(TIMEOUT / 2);
                } catch (InterruptedException exception) {
                }
            }
        }

        return thread;
    }

    private final int id;
    private final int count;
    private final Socket socket;
    private final String model;
    private final FeatureMap featureMap;
    private final transient Random random = new Random();
    private HDHRPrimeClient client = null;
    private List<LineupEntry> lineup = null;

    /**
     * Sole public constructor.
     *
     * @param   address         The {@link InetAddress}.
     */
    public HDHRTuner(InetAddress address) { this(ping(address)); }

    private static DiscoverReply ping(InetAddress address) {
        DiscoverReply reply = null;

        try (DatagramSocket socket = new DatagramSocket()) {
            socket.setBroadcast(true);
            socket.setReuseAddress(true);
            socket.setSoTimeout(1000);

            new DiscoverRequest().send(socket, address, DISCOVER_UDP_PORT);

            reply = new DiscoverReply();
            reply.receive(socket);
        } catch (Exception exception) {
            reply = null;
        }

        return reply;
    }

    private HDHRTuner(DiscoverReply reply) {
        try {
            id = reply.getID();
            count = reply.getCount();

            socket = new Socket(reply.getInetAddress(), CONTROL_TCP_PORT);
            socket.setKeepAlive(true);
            socket.setReuseAddress(true);
            socket.setSoTimeout(2500);

            model = get(0, "/sys/hwmodel");
            featureMap = new FeatureMap();
        } catch (Exception exception) {
            throw new ExceptionInInitializerError(exception);
        }
    }

    /**
     * @return  Tuner ID
     */
    public int getID() { return id; }

    /**
     * @return  Tuner Count
     */
    public int getCount() { return count; }

    /**
     * @return  Tuner {@link InetAddress}
     */
    public InetAddress getInetAddress() { return socket.getInetAddress(); }

    /**
     * @return  Tuner {@link URI}
     */
    public URI getURI() {
        URI uri = null;

        try {
            uri =
                new URI("http", getInetAddress().getHostAddress(), "/", null);
        } catch (URISyntaxException exception) {
        }

        return uri;
    }

    /**
     * @return  Tuner {@code /sys/hwmodel}
     */
    public String getModel() { return (model != null) ? model : "unknown"; }

    /**
     * @return  Tuner {@code /sys/features}
     */
    public Map<String,Set<String>> getFeature() { return featureMap; }

    /**
     * @return  {@link HDHRPrimeClient}
     */
    public HDHRPrimeClient getClient() {
        synchronized (this) {
            if (client == null) {
                client =
                    new HDHRPrimeClient(getInetAddress().getHostAddress());
            }
        }

        return client;
    }

    /**
     * @return  {@link HDHRPrimeClient#getLineup()}
     */
    public List<LineupEntry> getLineup() {
        synchronized (this) {
            if (lineup == null || lineup.isEmpty()) {
                try {
                    lineup = getClient().getLineup();
                } catch (Exception exception) {
                    lineup = Collections.emptyList();
                }
            }
        }

        return lineup;
    }

    /**
     * Method to obtain a lock on a tuner.
     *
     * @param   tuner           The tuner number.
     *
     * @return  The lock key value.
     *
     * @throws  IOException     If the tuner cannot be locked.
     */
    public int lock(int tuner) throws IOException {
        int key = 0;

        try {
            while (key == 0) {
                key = Math.abs(random.nextInt()) & 0xFFFFFFFF;
            }

            String name = format("/tuner%d/lockkey", tuner);
            String value = format("%d", key);
            GetSetReply reply = new GetSetReply();

            new GetSetRequest(0, name, value).send(socket);
            reply.receive(socket);

            if (reply.getErrorMessage() != null) {
                throw new IOException(reply.getErrorMessage());
            }

            Map<String,String> map = reply.map();

            if (NetworkInterface.getByInetAddress(InetAddress.getByName(map.get(name))) == null) {
                throw new IOException("Cannot lock " + name);
            }
        } catch (IOException exception) {
            throw exception;
        } catch (Exception exception) {
            throw new IOException(exception);
        }

        return key;
    }

    /**
     * Method to unlock a tuner.
     *
     * @param   tuner           The tuner number.
     * @param   key             The key value.
     *
     * @throws  IOException     If the tuner cannot be unlocked.
     */
    public void unlock(int tuner, int key) throws IOException {
        if (key != 0) {
            set(key, format("/tuner%d/lockkey", tuner), format(NONE));
        }
    }

    /**
     * Method to get a tuner lock owner.
     *
     * @param   tuner           The tuner number.
     * @param   key             The key value.
     *
     * @return  The {@link InetAddress} of the owner (or {@code null} if
     *          there is none).
     *
     * @throws  IOException     If the tuner locker cannot be determined.
     */
    public InetAddress locker(int tuner, int key) throws IOException {
        String string = get(key, format("/tuner%d/lockkey", tuner));

        return (! isNone(string)) ? InetAddress.getByName(string) : null;
    }

    private boolean isNone(String string) {
        return StringUtils.isEmpty(string) || string.equals(NONE);
    }

    /**
     * Method to get an option value from this {@link HDHRTuner}.
     *
     * @param   key             The tuner lockkey (if set).
     * @param   name            The option name.
     *
     * @return  The option value.
     *
     * @throws  IOException     If the option cannot be retrieved.
     */
    public String get(int key, String name) throws IOException {
        GetSetReply reply = new GetSetReply();

        new GetSetRequest(key, name, null).send(socket);
        reply.receive(socket);

        if (reply.getErrorMessage() != null) {
            throw new IOException(name + ": " + reply.getErrorMessage());
        }

        return reply.map().get(name);
    }

    /**
     * Method to set an option value for this {@link HDHRTuner}.
     *
     * @param   key             The tuner lockkey (if set).
     * @param   name            The option name.
     * @param   value           The option value.
     * @param   pairs           Optional name/value pairs.
     *
     * @throws  IOException     If the option(s) cannot be set.
     */
    public void set(int key,
                    String name, String value,
                    String... pairs) throws IOException {
        GetSetReply reply = new GetSetReply();

        new GetSetRequest(key, name, value, pairs).send(socket);
        reply.receive(socket);

        if (reply.getErrorMessage() != null) {
            throw new IOException(name + ": " + reply.getErrorMessage());
        }

        Map<String,String> map = reply.map();

        check(name, value, map);

        for (int i = 0; i < pairs.length; i += 2) {
            check(pairs[i], pairs[i + 1], map);
        }
    }

    private void check(String name, String value,
                       Map<String,String> map) throws IOException {
        if (! value.equals(map.get(name))) {
            throw new IOException("Could not set " + name + " to " + value);
        }
    }

    /**
     * Method to get the configuration options supported by this
     * {@link HDHRTuner}.
     *
     * @return  The {@link SortedSet} of options.
     *
     * @throws  IOException     If the options cannot be retrieved.
     */
    public SortedSet<String> options() throws IOException {
        TreeSet<String> set = new TreeSet<>();
        String string = get(0, "help");

        for (String line : string.split(LF)) {
            if (line.startsWith(SLASH)) {
                String option = line.split(SPACE, 2)[0].trim();

                for (int i = 0, n = getCount(); i < n; i += 1) {
                    set.add(option.replaceAll("<n>", String.valueOf(i)));
                }
            }
        }

        return set;
    }

    /**
     * Method to scan the first tuner available and return a {@link List} of
     * {@link HDHRProgram}s found.
     *
     * @return  The {@link List} of {@link HDHRProgram}s found.
     *
     * @throws  IOException     If the {@link HDHRProgram}s cannot be
     *                          retrieved.
     */
    public List<HDHRProgram> scan() throws IOException {
        List<HDHRProgram> list = null;
        IOException thrown = null;

        for (int tuner = 0, n = getCount(); tuner < n; tuner += 1) {
            int key = 0;

            try {
                key = lock(tuner);
                list = scan(tuner, key);
                thrown = null;
                break;
            } catch (IOException exception) {
                thrown = exception;
                continue;
            } finally {
                unlock(tuner, key);
            }
        }

        if (thrown != null) {
            throw thrown;
        }

        return list;
    }

    /**
     * Method to scan the specified tuner and return a {@link List} of
     * {@link HDHRProgram}s found.
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     *
     * @return  The {@link List} of {@link HDHRProgram}s found.
     *
     * @throws  IOException     If the {@link HDHRProgram}s cannot be
     *                          retrieved.
     */
    public List<HDHRProgram> scan(int tuner, int key) throws IOException {
        if (! (0 <= tuner && tuner < getCount())) {
            throw new IllegalArgumentException("tuner=" + tuner);
        }

        ArrayList<HDHRProgram> list = new ArrayList<>();

        for (int frequency : new TreeSet<Integer>(Channel.MAP.keySet())) {
            StatusMap status = null;

            try {
                channel(tuner, key, frequency);
                status = new StatusMap(tuner, key);
            } catch (IOException exception) {
                continue;
            }

            long deadline = System.currentTimeMillis() + 2500;

            do {
                status = new StatusMap(tuner, key);

                if (status.hasLock() && status.getSS() > 45) {
                    break;
                } else {
                    sleep(250);
                }
            } while (System.currentTimeMillis() < deadline);

            if (status.hasLock()) {
                deadline = System.currentTimeMillis() + 5000;

                do {
                    status = new StatusMap(tuner, key);

                    if (status.getSEQ() >= 100) {
                        break;
                    } else {
                        sleep(250);
                    }
                } while (System.currentTimeMillis() < deadline);

                if (status.getSEQ() >= 100) {
                    sleep(5000);

                    StreaminfoMap streaminfo =
                        new StreaminfoMap(tuner, key, frequency);

                    if (streaminfo.getTSID() != null) {
                        if (! streaminfo.isEmpty()) {
                            list.addAll(streaminfo.values());
                        }
                    }
                }
            }
        }

        target(tuner, key, null);

        return list;
    }

    /**
     * Method to get the {@code /tuner<n>/channelmap} value on the specified
     * tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.

     * @return  The value of the {@code /tuner<n>/channelmap}.
     *
     * @throws  IOException     If the channel map name cannot be
     *                          retrieved.
     */
    public String channelmap(int tuner, int key) throws IOException {
        String string = get(key, format("/tuner%d/channelmap", tuner));

        return (! isNone(string)) ? string : null;
    }

    /**
     * Method to specify the {@code /tuner<n>/channelmap} on the specified
     * tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   string          The name of the {@code /tuner<n>/channelmap}.
     *
     * @throws  IOException     If the channel map name cannot be
     *                          specified.
     */
    public void channelmap(int tuner, int key,
                           String string) throws IOException {
        set(key,
            format("/tuner%d/channelmap", tuner),
            (! isNone(string)) ? string : NONE);
    }

    /**
     * Method to tune the specified tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   channel         The channel specification (number or
     *                          frequency with optional modulation).
     * @param   program         The program (subchannel) specification.
     *
     * @throws  IOException     If the tuner cannot be tuned.
     *
     * @see #channel(int,int,String)
     * @see #program(int,int,int)
     */
    public void channel(int tuner, int key,
                        String channel, int program) throws IOException {
        channel(tuner, key, channel);

        if (! isNone(channel)) {
            program(tuner, key, program);
        }
    }

    /**
     * Method to tune the specified tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   channel         The channel specification (number or
     *                          frequency).
     * @param   program         The program (subchannel) specification.
     *
     * @throws  IOException     If the tuner cannot be tuned.
     *
     * @see #channel(int,int,int)
     * @see #program(int,int,int)
     */
    public void channel(int tuner, int key,
                        int channel, int program) throws IOException {
        channel(tuner, key, channel);
        program(tuner, key, program);
    }

    /**
     * Method to tune the specified tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   channel         The channel specification (number or
     *                          frequency with optional modulation).
     *
     * @throws  IOException     If the tuner cannot be tuned.
     */
    public void channel(int tuner, int key,
                        String channel) throws IOException {
        if (! isNone(channel)) {
            if (channel.indexOf(COLON) < 0) {
                channel = AUTO + COLON + channel;
            }
        } else {
            channel = NONE;
        }

        set(key, format("/tuner%d/channel", tuner), channel);
    }

    /**
     * Method to tune the specified tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   channel         The channel specification (number or
     *                          frequency).
     *
     * @throws  IOException     If the tuner cannot be tuned.
     */
    public void channel(int tuner, int key, int channel) throws IOException {
        channel(tuner, key, format("%d", channel));
    }

    /**
     * Method to tune the specified tuner,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   program         The program (subchannel) specification.
     *
     * @throws  IOException     If the tuner cannot be tuned.
     */
    public void program(int tuner, int key, int program) throws IOException {
        set(key, format("/tuner%d/program", tuner), format("%d", program));
    }

    /**
     * Method to set the tuner target,
     *
     * @param   tuner           The tuner to scan.
     * @param   key             The key value.
     * @param   locator         The target {@link URI}.
     *
     * @throws  IOException     If the tuner target cannot be set.
     */
    public void target(int tuner, int key, URI locator) throws IOException {
        set(key,
            format("/tuner%d/target", tuner),
            (locator != null) ? locator.toASCIIString() : NONE);
    }

    @Override
    public String toString() {
        StringBuilder buffer =
            new StringBuilder(getModel())
            .append(COLON).append(Integer.toString(getID(), 16))
            .append(LB).append(Integer.toString(getCount())).append(RB);
        InetAddress address = getInetAddress();

        if (address != null) {
            buffer.append(AT).append(address.getHostAddress());
        }

        return buffer.toString();
    }

    private static void sleep(long milliseconds) {
        try {
            Thread.sleep(milliseconds);
        } catch (InterruptedException exception) {
        }
    }

    private static final int TIMEOUT = 10 * 1000;

    private static class DiscoveryThread extends Thread {
        private final DatagramSocket socket;
        private final Set<InetAddress> addresses;
        private final ConcurrentHashMap<InetAddress,DiscoverReply> map =
            new ConcurrentHashMap<>();

        public DiscoveryThread() {
            super();

            try {
                socket = new DatagramSocket();
                socket.setBroadcast(true);
                socket.setReuseAddress(true);
                socket.setSoTimeout(TIMEOUT);

                ArrayList<InterfaceAddress> list = new ArrayList<>();

                Collections.list(NetworkInterface.getNetworkInterfaces())
                    .stream()
                    .forEach(t -> list.addAll(t.getInterfaceAddresses()));

                addresses =
                    list.stream()
                    .filter(Objects::nonNull)
                    .map(t -> t.getBroadcast())
                    .filter(Objects::nonNull)
                    .collect(Collectors.toSet());
            } catch (Exception exception) {
                throw new ExceptionInInitializerError(exception);
            }

            setDaemon(true);
            setName(getClass().getName());
        }

        public Map<InetAddress,DiscoverReply> map() { return map; }

        @Override
        public void run() {
            try {
                List<Thread> list = asList(new Receiver(), new Sender());

                for (Thread thread : list) {
                    thread.start();
                }

                for (Thread thread : list) {
                    try {
                        thread.join();
                    } catch (InterruptedException exception) {
                        continue;
                    }
                }
            } finally {
                if (socket != null) {
                    socket.close();
                }
            }
        }

        private class Receiver extends Thread {
            public Receiver() {
                super();

                setName(getClass().getName());
            }

            @Override
            public void run() {
                HashMap<InetAddress,DiscoverReply> map = new HashMap<>();

                for (;;) {
                    try {
                        DiscoverReply reply = new DiscoverReply();

                        reply.receive(socket);
                        map.put(reply.getInetAddress(), reply);

                        map().putAll(map);
                    } catch (SocketTimeoutException exception) {
                        map().keySet().retainAll(map.keySet());
                        map.clear();
                        continue;
                    } catch (IOException exception) {
                        break;
                    }
                }
            }
        }

        private class Sender extends Thread {
            public Sender() {
                super();

                setName(getClass().getName());
            }

            @Override
            public void run() {
                for (;;) {
                    DiscoverRequest request = new DiscoverRequest();

                    for (InetAddress address : addresses) {
                        try {
                            request.send(socket, address, DISCOVER_UDP_PORT);
                        } catch (IOException exception) {
                            break;
                        }
                    }

                    try {
                        Thread.sleep(TIMEOUT);
                    } catch (InterruptedException exception) {
                        continue;
                    }
                }
            }
        }
    }

    /**
     * {@code /sys/features} {@link Map}.
     */
    private class FeatureMap extends LinkedHashMap<String,Set<String>> {
        private static final long serialVersionUID = -6053149128443314847L;

        protected FeatureMap() throws IOException {
            this(HDHRTuner.this.get(0, "/sys/features"));
        }

        private FeatureMap(String features) {
            super();

            for (String line : features.split("[\\n]+")) {
                line = line.trim();

                if (! StringUtils.isEmpty(line)) {
                    String[] entry = line.split(COLON, 2);

                    put(entry[0].trim(), new SetImpl(entry[1]));
                }
            }
        }

        private class SetImpl extends LinkedHashSet<String> {
            private static final long serialVersionUID = 6764399687983160653L;

            public SetImpl(String string) {
                super();

                addAll(asList(string.trim().split("[\\p{Space}]+")));
                remove(StringUtils.EMPTY);
            }
        }
    }

    /**
     * {@code /tuner<n>/status} {@link Map}.
     */
    private class StatusMap extends LinkedHashMap<String,String> {
        private static final long serialVersionUID = -4078700272266143306L;

        private static final String LOCK = "lock";
        private static final String SEQ = "seq";
        private static final String SNQ = "snq";
        private static final String SS = "ss";

        protected StatusMap(int tuner, int key) throws IOException {
            this(HDHRTuner.this.get(key, format("/tuner%d/status", tuner)));
        }

        private StatusMap(String status) {
            super();

            for (String entry : status.split("[\\p{Space}]+")) {
                String[] pair = entry.split("=", 2);

                put(pair[0], pair[1]);
            }
        }

        public String getModulation() { return get(LOCK); }
        public int getSEQ() { return intValue(get(SEQ)); }
        public int getSNQ() { return intValue(get(SNQ)); }
        public int getSS() { return intValue(get(SS)); }

        public boolean hasLock() {
            return containsKey(LOCK) && (! get(LOCK).equals(NONE));
        }

        private int intValue(String string) {
            return (string != null) ? Integer.parseInt(string) : 0;
        }
    }

    /**
     * {@code /tuner<n>/streaminfo} {@link SortedMap}.
     */
    private class StreaminfoMap extends TreeMap<Integer,HDHRProgram> {
        private static final long serialVersionUID = 8619516460294488583L;

        private final Integer tsid;
        private final LinkedHashSet<String> flags = new LinkedHashSet<>();

        protected StreaminfoMap(int tuner, int key,
                                int frequency) throws IOException {
            this(frequency,
                 new StatusMap(tuner, key).getModulation(),
                 HDHRTuner.this.get(key,
                                    format("/tuner%d/streaminfo", tuner)));
        }

        private StreaminfoMap(int frequency,
                              String modulation, String streaminfo) {
            super();

            ArrayList<String> list = new ArrayList<>();

            list.addAll(asList(streaminfo.split(LF)));

            for (int i = 0, n = list.size(); i < n; i += 1) {
                list.set(i, list.get(i).trim());
            }

            while (list.remove(StringUtils.EMPTY)) {
            }

            Integer tsid = null;
            Iterator<String> iterator = list.iterator();

            while (iterator.hasNext()) {
                String line = iterator.next();

                if (line.startsWith("tsid=")) {
                    tsid = Integer.decode(line.split(EQUALS, 2)[1].trim());
                    iterator.remove();
                }
            }

            this.tsid = tsid;

            iterator = list.iterator();

            while (iterator.hasNext()) {
                String line = iterator.next();

                if (HDHRProgram.PATTERN.matcher(line).matches()) {
                    HDHRProgram program =
                        new HDHRProgram(frequency, modulation, tsid, line);

                    put(program.getNumber(), program);
                    iterator.remove();
                }
            }

            flags.addAll(list);
        }

        public Integer getTSID() { return tsid; }

        public Set<String> getFlags() { return flags; }

        @Override
        public String toString() {
            return ("tsid="
                    + ((tsid != null)
                           ? ("0x" + Integer.toString(tsid, 16))
                           : NONE)
                    + flags + super.toString());
        }
    }

    private static class Pkt {
        private static final SortedMap<Short,String> MAP = new TreeMap<>();

        static {
            try {
                List<Field> list =
                    FieldUtils.getAllFieldsList(HDHRTuner.class)
                    .stream()
                    .filter(t -> Modifier.isStatic(t.getModifiers()))
                    .filter(t -> Short.class.isAssignableFrom(t.getType()))
                    .collect(Collectors.toList());

                for (Field field : list) {
                    MAP.put(field.getShort(null), field.getName());
                }
            } catch (Exception exception) {
                throw new ExceptionInInitializerError(exception);
            }
        }

        private final ByteBuffer buffer;
        private final ByteBuffer payload;
        private transient String message = null;

        public Pkt() { this((short) 0); }

        public Pkt(short type) {
            this(ByteBuffer.allocate(MAX_PACKET_SIZE));

            buffer.rewind();
            payload.rewind();

            setType(type);
            setPayloadLength(MAX_PAYLOAD_SIZE);
        }

        private Pkt(ByteBuffer buffer) {
            this.buffer = buffer.order(BIG_ENDIAN);
            this.buffer.getShort();
            this.buffer.getShort();

            this.payload = buffer.slice();
        }

        protected ByteBuffer buffer() { return buffer; }
        protected ByteBuffer payload() { return payload; }

        public int getLength() { return getCRCOffset() + 4; }

        public short getType() { return buffer.getShort(0); }
        protected void setType(short type) { buffer.putShort(0, type); }

        protected void put(byte tag, byte value) {
            payload.put(tag); putLen(1); payload.put(value);
        }

        protected void put(byte tag, short value) {
            payload.put(tag); putLen(2); payload.putShort(value);
        }

        protected void put(byte tag, int value) {
            payload.put(tag); putLen(4); payload.putInt(value);
        }

        protected void put(byte tag, String value) {
            payload.put(tag);

            byte[] bytes = value.getBytes(UTF_8);

            putLen(bytes.length + 1);
            payload.put(bytes);
            payload.put((byte) 0);
        }

        private void putLen(int len) {
            if (len <= 127) {
                payload.put((byte) (len & 0xFF));
            } else {
                payload.put((byte) ((len | 0x80) & 0xFF));
                payload.put((byte) ((len >> 7)   & 0xFF));
            }
        }

        protected String toString(ByteBuffer buffer) {
            return new String(buffer.array(),
                              buffer.arrayOffset(),
                              buffer.limit() - 1,
                              UTF_8);
        }

        public int getPayloadLength() { return buffer.getShort(2); }
        protected void setPayloadLength(int length) {
            buffer.putShort(2, (short) (length & 0xFFFF));
            payload.limit(getPayloadLength());
        }

        public int getCRCOffset() { return 4 + getPayloadLength(); }

        protected void seal(int length) {
            setPayloadLength(length);
            buffer.position(getCRCOffset());

            CRC32 crc = new CRC32();

            crc.update(buffer.array(), 0, buffer.position());

            buffer.order(LITTLE_ENDIAN);
            buffer.putInt((int) (crc.getValue() & 0xFFFFFFFF));
            buffer.order(BIG_ENDIAN);
            buffer.flip();
        }

        protected void parse() {
            setPayloadLength(getPayloadLength());

            ByteBuffer payload = payload();

            while (payload.hasRemaining()) {
                byte tag = payload.get();
                int len = payload.get();

                if ((len & 0x80) != 0) {
                    len &= 0x7F;
                    len |= ((int) payload.get()) << 7;
                }

                ByteBuffer value = payload.slice();

                value.limit(len);

                payload.position(payload.position() + len);

                parse(tag, value);
            }
        }

        protected void parse(byte tag, ByteBuffer value) {
            switch (tag) {
            case TAG_ERROR_MESSAGE:
                message = toString(value);
                break;

            default:
                break;
            }
        }

        public String getErrorMessage() { return message; }

        public void receive(DatagramSocket socket) throws IOException {
            buffer().clear();

            DatagramPacket packet =
                new DatagramPacket(buffer().array(), getLength());

            socket.receive(packet);

            receive(packet);
        }

        protected void receive(DatagramPacket packet) { parse(); }

        public void receive(Socket socket) throws IOException {
            buffer().clear();

            int length =
                socket.getInputStream()
                .read(buffer.array(), 0, buffer.limit());

            buffer.limit(length);

            parse();
        }

        public void send(DatagramSocket socket,
                         InetAddress address, int port) throws IOException {
            DatagramPacket packet =
                new DatagramPacket(buffer().array(), getLength());

            packet.setAddress(address);
            packet.setPort(port);

            socket.send(packet);
        }

        public void send(Socket socket) throws IOException {
            socket.getOutputStream().write(buffer().array(), 0, getLength());
        }

        @Override
        public String toString() {
            String type = MAP.get(getType());

            return (LB + ((type != null) ? type : String.valueOf(getType()))
                    + COLON + getPayloadLength() + RB);
        }
    }

    private static class DiscoverRequest extends Pkt {
        public DiscoverRequest() {
            super(TYPE_DISCOVER_REQ);

            put(TAG_DEVICE_TYPE, DEVICE_TYPE_TUNER);
            put(TAG_DEVICE_ID, DEVICE_ID_WILDCARD);
            put(TAG_TUNER_COUNT, (byte) 0);

            payload().limit(payload().position());

            seal(payload().limit());
        }
    }

    private static class DiscoverReply extends Pkt {
        private InetAddress address = null;
        private int id = -1;
        private int count = -1;

        public DiscoverReply() { super(); }

        public InetAddress getInetAddress() { return address; }
        public int getID() { return id; }
        public int getCount() { return count; }

        @Override
        protected void receive(DatagramPacket packet) {
            super.receive(packet);

            address = packet.getAddress();
        }

        @Override
        protected void parse() {
            super.parse();

            if (count == 0) {
                switch (id >> 20) {
                case 0x102:
                    count = 1;
                    break;

                case 0x100:
                case 0x101:
                case 0x121:
                    count = 2;
                    break;

                default:
                    break;
                }
            }
        }

        @Override
        protected void parse(byte tag, ByteBuffer value) {
            super.parse(tag, value);

            switch (tag) {
            case TAG_DEVICE_ID:
                id = value.getInt();
                break;

            case TAG_TUNER_COUNT:
                count = value.get();
                break;

            default:
                break;
            }
        }
    }

    private class GetSetRequest extends Pkt {
        public GetSetRequest(int key,
                             String name, String value, String... pairs) {
            super(TYPE_GETSET_REQ);

            put(TAG_GETSET_NAME, name);

            if (value != null) {
                put(TAG_GETSET_VALUE, value);
            }

            for (int i = 0; i < pairs.length; i += 2) {
                name = pairs[i];
                value = pairs[i + 1];

                put(TAG_GETSET_NAME, name);

                if (value != null) {
                    put(TAG_GETSET_VALUE, value);
                }
            }

            put(TAG_GETSET_LOCKKEY, key);

            payload().limit(payload().position());

            seal(payload().limit());
        }
    }

    private class GetSetReply extends Pkt {
        private final TreeMap<String,String> map = new TreeMap<>();
        private transient String name = null;

        public GetSetReply() { super(); }

        public Map<String,String> map() { return map; }

        @Override
        protected void parse() {
            super.parse();

            if (name != null) {
                map.put(name, null);
                name = null;
            }
        }

        @Override
        protected void parse(byte tag, ByteBuffer value) {
            super.parse(tag, value);

            switch (tag) {
            case TAG_GETSET_NAME:
                if (name != null) {
                    map.put(name, null);
                    name = null;
                }

                name = toString(value);
                break;

            case TAG_GETSET_VALUE:
                map.put(name, toString(value));
                name = null;
                break;

            default:
                break;
            }
        }
    }
}