# Copyright 2023 Jim Unroe <rock.unroe@gmail.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging
import struct

from chirp import (
    bitwise,
    chirp_common,
    directory,
    errors,
    memmap,
    util,
)
from chirp.settings import (
    RadioSetting,
    RadioSettingGroup,
    RadioSettings,
    RadioSettingValueBoolean,
    RadioSettingValueInteger,
    RadioSettingValueList,
    RadioSettingValueString,
)

LOG = logging.getLogger(__name__)

MEM_FORMAT = """
struct {
  lbcd rxfreq[4];     // 0-3
  lbcd txfreq[4];     // 4-7
  ul16 rxtone;        // 8-9
  ul16 txtone;        // A-B
  u8 unknown1:4,      // C
     scode:4;         //     Signaling
  u8 unknown2:6,      // D
     pttid:2;         //     PTT-ID
  u8 unknown3:6,      // E
     txpower:2;       //     Power Level  0 = H, 1 = L, 2 = M
  u8 unknown4:1,      // F
     narrow:1,        //     Bandwidth  0 = Wide, 1 = Narrow
     encrypt:2,       //     Encrypt
     bcl:1,           //     BCL
     scan:1,          //     Scan  0 = Skip, 1 = Scan
     unknown5:1,      //
     learning:1;      //     Learning
  lbcd code[3];       // 0-2 Code
  u8 unknown6;        // 3
  char name[12];      // 4-F 12-character Alpha Tag
} memory[%d];

#seekto 0x9000;
struct {
  u8 unused:4,        // 9000
     sql:4;           //      Squelch Level
  u8 unused_9001:6,   // 9001
     save:2;          //      Battery Save
  u8 unused_9002:4,   // 9002
     vox:4;           //      VOX Level
  u8 unused_9003:4,   // 9003
     abr:4;           //      Auto BackLight
  u8 unused_9004:7,   // 9004
     tdr:1;           //      TDR
  u8 unused_9005:5,   // 9005
     tot:3;           //      Time-out Timer
  u8 unused_9006:7,   // 9006
     beep:1;          //      Beep
  u8 unused_9007:7,   // 9007
     voice:1;         //      Voice Prompt
  u8 unused_9008:7,   // 9008
     language:1;      //      Language
  u8 unused_9009:6,   // 9009
     dtmfst:2;        //      DTMF ST
  u8 unused_900a:6,   // 900A
     screv:2;         //      Scan Mode
  u8 unused_900B:4,   // 900B
     pttid:4;         //      PTT-ID
  u8 unused_900c:5,   // 900C
     pttlt:3;         //      PTT Delay
  u8 unused_900d:6,   // 900D
     mdfa:2;          //      Channel_A Display
  u8 unused_900e:6,   // 900E
     mdfb:2;          //      Channel_B Display
  u8 unknown_900f;    // 900F
  u8 unused_9010:4,   // 9010
     autolk:4;        //      Key Auto Lock
  u8 unused_9011:6,   // 9011
     almode:2;        //      Alarm Mode
  u8 unused_9012:7,   // 9012
     alarmsound:1;    //      Alarm Sound
  u8 unused_9013:6,   // 9013
     dualtx:2;        //      Dual TX
  u8 unused_9014:7,   // 9014
     ste:1;           //      Tail Noise Clear
  u8 unused_9015:4,   // 9015
     rpste:4;         //      RPT Noise Clear
  u8 unused_9016:4,   // 9016
     rptrl:4;         //      RPT Noise Delay
  u8 unused_9017:6,   // 9017
     roger:2;         //      Roger
  u8 unknown_9018;    // 9018
  u8 unused_9019:7,   // 9019
     fmradio:1;       //      FM Radio
  u8 unused_901a1:3,  // 901A
     vfomrb:1,        //      WorkMode B
     unused_901a2:3,  //
     vfomra:1;        //      WorkMode A
  u8 unused_901b:7,   // 901B
     kblock:1;        //      KB Lock
  u8 unused_901c:7,   // 901C
     ponmsg:1;        //      Power On Msg
  u8 unknown_901d;    // 901D
  u8 unused_901e:6,   // 901E
     tone:2;          //      Pilot
  u8 unknown_901f;    // 901F
  u8 unused_9020:4,   // 9020
     voxd:4;          //      VOX Delay
  u8 unused_9021:4,   // 9021
     menuquit:4;      //      Menu Auto Quit
  u8 unused_9022:7,   // 9022
     tailcode:1;      //      Tail Code (RT-470L)
  u8 unknown_9023;    // 9023
  u8 unknown_9024;    // 9024
  u8 unknown_9025;    // 9025
  u8 unknown_9026;    // 9026
  u8 unknown_9027;    // 9027
  u8 unknown_9028;    // 9028
  u8 unused_9029:6,   // 9029
     qtsave:2;        //      QT Save Type
  u8 ani;             // 902A ANI
  u8 skey2_sp;        // 902B Skey2 Short
  u8 skey2_lp;        // 902C Skey2 Long
  u8 skey3_sp;        // 902D Skey3 Short
  u8 topkey_sp;       // 902E Top Key (RT-470L)
  u8 unused_902f:6,   // 902F
     rxendtail:2;     //      RX END TAIL (RT-470)
                      //      TAIL PHASE (A36plus)
  u8 skey3_lp;        // 9030 Skey3 Long (RT-470L)
                      //      RX END TAIL (A36plus)
} settings;

#seekto 0xA006;
struct {
  u8 unknown_A006;    // A006
  u8 unused_a007:5,   // A007
     dtmfon:3;        //      DTMF Speed (on time)
  u8 unused_a008:5,   // A008
     dtmfoff:3;       //      DTMF Speed (off time)
} dtmf;

#seekto 0xA020;
struct {
  u8 code[5];         //      5-character DTMF Encoder Groups
  u8 unused[11];
} pttid[15];

#seekto 0xB000;
struct {
  u8 code[3];         //      3-character ANI Code Groups
} anicodes[60];

#seekto 0xB0C0;
struct {
  char name[10];      //      10-character ANI Code Group Names
  u8 unused[6];
} aninames[%d];

"""

MEM_FORMAT_A36PLUS = """
#seekto 0xB200;
struct {
  char name[10];      //      10-character Custom CH Names (Talkpod A36plus)
  u8 unused[6];
} customnames[30];

"""


CMD_ACK = b"\x06"

DTCS = tuple(sorted(chirp_common.DTCS_CODES + (645,)))

DTMF_CHARS = "0123456789 *#ABCD"

TXPOWER_HIGH = 0x00
TXPOWER_LOW = 0x01
TXPOWER_MID = 0x02

ABR_LIST = ["On", "5 seconds", "10 seconds", "15 seconds", "20 seconds",
            "30 seconds", "1 minute", "2 minutes", "3 minutes"]
ALMODE_LIST = ["Site", "Tone", "Code"]
AUTOLK_LIST = ["Off"] + ABR_LIST[1:4]
DTMFSPEED_LIST = ["50 ms", "100 ms", "200 ms", "300 ms", "500 ms"]
DTMFST_LIST = ["Off", "KeyBoard Side Tone", "ANI Side Tone", "KB ST + ANI ST"]
DUALTX_LIST = ["Off", "A", "B"]
ENCRYPT_LIST = ["Off", "DCP1", "DCP2", "DCP3"]
LANGUAGE_LIST = ["English", "Chinese"]
MDF_LIST = ["Name", "Frequency", "Channel"]
MENUQUIT_LIST = ["%s seconds" % x for x in range(5, 55, 5)] + ["60 seconds"]
OFF1TO9_LIST = ["Off"] + ["%s" % x for x in range(1, 10)]
PONMSG_LIST = ["Logo", "Voltage"]
PTTID_LIST = ["Off", "BOT", "EOT", "Both"]
PTTIDCODE_LIST = ["%s" % x for x in range(1, 16)]
PTTLT_LIST = ["None", "100 ms"] + \
             ["%s ms" % x for x in range(200, 1200, 200)]
QTSAVE_LIST = ["All", "RX", "TX"]
ROGER_LIST = ["OFF", "BEEP", "TONE1200"]
RPSTE_LIST = ["Off"] + ["%s ms" % x for x in range(100, 1100, 100)]
SAVE_LIST = ["Off", "Normal", "Super", "Deep"]
SCREV_LIST = ["Time (TO)", "Carrier (CO)", "Search (SE)"]
TAILCODE_LIST = ["55 Hz", "62.5 Hz"]
TAILPHASE_LIST = ["None", "120 Shift", "180 Shift", "240 Shift"]
TONERXEND_LIST = ["Off", "MDC-1200"]
TONE_LIST = ["1000 Hz", "1450 Hz", "1750 Hz", "2100 Hz"]
TOT_LIST = ["Off", "30 seconds", "60 seconds", "120 seconds", "240 seconds",
            "480 seconds"]
VOXD_LIST = ["%s seconds" % str(x / 10) for x in range(5, 21)]
WORKMODE_LIST = ["VFO Mode", "Channel Mode"]

ALL_SKEY_CHOICES = ["OFF",
                    "FM Radio",
                    "TX Power Level",
                    "Scan",
                    "Search",
                    "Flashlight",
                    "NOAA Weather",
                    "Monitor",
                    "PTT B",
                    "SOS",
                    "DTMF",
                    "REVERSE",
                    "REMOTE Scan"]

ALL_SKEY_VALUES = [0xFF,
                   0x07,
                   0x0A,
                   0x1C,
                   0x1D,
                   0x08,
                   0x0C,
                   0x05,
                   0x01,
                   0x03,
                   0x2A,
                   0x2D,
                   0x23]


def _enter_programming_mode(radio):
    serial = radio.pipe

    exito = False
    for i in range(0, 5):
        serial.write(radio._magic)
        ack = serial.read(1)

        try:
            if ack == CMD_ACK:
                exito = True
                break
        except Exception:
            LOG.debug("Attempt #%s, failed, trying again" % i)
            pass

    # check if we had EXITO
    if exito is False:
        msg = "The radio did not accept program mode after five tries.\n"
        msg += "Check you interface cable and power cycle your radio."
        raise errors.RadioError(msg)

    try:
        serial.write(b"F")
        ident = serial.read(8)
    except Exception:
        raise errors.RadioError("Error communicating with radio")

    if ident not in radio._fingerprint:
        LOG.debug(util.hexprint(ident))
        raise errors.RadioError("Radio returned unknown identification string")

    if radio.MODEL == "RT-470X":
        if ident in radio._fingerprint_pcb1:
            LOG.info("Radtel RT-470X - original pcb")
            radio.RT470X_ORIG = True
        elif ident in radio._fingerprint_pcb2:
            LOG.info("Radtel RT-470X - pcb2")
            radio.RT470X_ORIG = False


def _exit_programming_mode(radio):
    serial = radio.pipe
    try:
        serial.write(b"E")
    except Exception:
        raise errors.RadioError("Radio refused to exit programming mode")


def _read_block(radio, block_addr, block_size):
    serial = radio.pipe

    cmd = struct.pack(">cHb", b'R', block_addr, block_size)
    expectedresponse = b"R" + cmd[1:]
    LOG.debug("Reading block %04x..." % (block_addr))

    try:
        serial.write(cmd)
        response = serial.read(4 + block_size)
        if response[:4] != expectedresponse:
            raise Exception("Error reading block %04x." % (block_addr))

        block_data = response[4:]
    except Exception:
        raise errors.RadioError("Failed to read block at %04x" % block_addr)

    return block_data


def _write_block(radio, block_addr, block_size):
    serial = radio.pipe

    cmd = struct.pack(">cHb", b'W', block_addr, block_size)
    data = radio.get_mmap()[block_addr:block_addr + block_size]

    LOG.debug("Writing Data:")
    LOG.debug(util.hexprint(cmd + data))

    try:
        serial.write(cmd + data)
        if serial.read(1) != CMD_ACK:
            raise Exception("No ACK")
    except Exception:
        raise errors.RadioError("Failed to send block "
                                "to radio at %04x" % block_addr)


def do_download(radio):
    LOG.debug("download")
    _enter_programming_mode(radio)

    data = b""

    status = chirp_common.Status()
    status.msg = "Cloning from radio"

    status.cur = 0
    status.max = radio._memsize

    for addr in range(0, radio._memsize, radio.BLOCK_SIZE):
        status.cur = addr + radio.BLOCK_SIZE
        radio.status_fn(status)

        block = _read_block(radio, addr, radio.BLOCK_SIZE)
        data += block

        LOG.debug("Address: %04x" % addr)
        LOG.debug(util.hexprint(block))

    _exit_programming_mode(radio)

    return memmap.MemoryMapBytes(data)


def do_upload(radio):
    status = chirp_common.Status()
    status.msg = "Uploading to radio"

    _enter_programming_mode(radio)

    status.cur = 0
    status.max = radio._memsize

    for start_addr, end_addr in radio._ranges:
        for addr in range(start_addr, end_addr, radio.BLOCK_SIZE_UP):
            status.cur = addr + radio.BLOCK_SIZE_UP
            radio.status_fn(status)
            _write_block(radio, addr, radio.BLOCK_SIZE_UP)

    _exit_programming_mode(radio)


def _split(rf, f1, f2):
    """Returns False if the two freqs are in the same band (no split)
    or True otherwise"""

    # determine if the two freqs are in the same band
    for low, high in rf.valid_bands:
        if f1 >= low and f1 <= high and \
                f2 >= low and f2 <= high:
            # if the two freqs are on the same Band this is not a split
            return False

    # if you get here is because the freq pairs are split
    return True


class JC8810base(chirp_common.CloneModeRadio):
    """MML JC-8810"""
    VENDOR = "MML"
    MODEL = "JC-8810base"
    BAUD_RATE = 57600
    NEEDS_COMPAT_SERIAL = False
    BLOCK_SIZE = 0x40
    BLOCK_SIZE_UP = 0x40

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=10.00),
                    chirp_common.PowerLevel("M", watts=8.00),
                    chirp_common.PowerLevel("L", watts=4.00)]

    VALID_BANDS = [(108000000, 136000000),
                   (136000000, 180000000),
                   (200000000, 260000000),
                   (330000000, 400000000),
                   (400000000, 520000000)]

    _magic = b"PROGRAMJC81U"
    _fingerprint = [b"\x00\x00\x00\x26\x00\x20\xD8\x04",
                    b"\x00\x00\x00\x42\x00\x20\xF0\x04",
                    b"\x00\x00\x00\x4A\x00\x20\xF8\x04"]

    _ranges = [
               (0x0000, 0x2000),
               (0x8000, 0x8040),
               (0x9000, 0x9040),
               (0xA000, 0xA140),
               (0xB000, 0xB300)
              ]
    _memsize = 0xB300
    _upper = 256
    _aninames = 30
    _mem_params = (_upper,  # number of channels
                   _aninames,  # number of aninames
                   )
    _valid_chars = chirp_common.CHARSET_ALPHANUMERIC + \
        "`~!@#$%^&*()-=_+[]\\{}|;':\",./<>?"

    def get_features(self):
        rf = chirp_common.RadioFeatures()
        rf.has_settings = True
        rf.has_bank = False
        rf.has_ctone = True
        rf.has_cross = True
        rf.has_rx_dtcs = True
        rf.has_tuning_step = False
        rf.can_odd_split = True
        rf.has_name = True
        rf.valid_name_length = 12
        rf.valid_characters = self._valid_chars
        rf.valid_skips = ["", "S"]
        rf.valid_tmodes = ["", "Tone", "TSQL", "DTCS", "Cross"]
        rf.valid_cross_modes = ["Tone->Tone", "Tone->DTCS", "DTCS->Tone",
                                "->Tone", "->DTCS", "DTCS->", "DTCS->DTCS"]
        rf.valid_power_levels = self.POWER_LEVELS
        rf.valid_duplexes = ["", "-", "+", "split", "off"]
        rf.valid_modes = ["FM", "NFM"]  # 25 kHz, 12.5 kHz.
        rf.valid_dtcs_codes = DTCS
        rf.memory_bounds = (1, self._upper)
        rf.valid_tuning_steps = [2.5, 5., 6.25, 8.33, 10., 12.5, 20., 25., 50.]
        rf.valid_bands = self.VALID_BANDS
        return rf

    def process_mmap(self):
        self._memobj = bitwise.parse(MEM_FORMAT % self._mem_params, self._mmap)

    def sync_in(self):
        """Download from radio"""
        try:
            data = do_download(self)
        except errors.RadioError:
            # Pass through any real errors we raise
            raise
        except Exception:
            # If anything unexpected happens, make sure we raise
            # a RadioError and log the problem
            LOG.exception('Unexpected error during download')
            raise errors.RadioError('Unexpected error communicating '
                                    'with the radio')
        self._mmap = data
        self.process_mmap()

    def sync_out(self):
        """Upload to radio"""
        try:
            do_upload(self)
        except Exception:
            # If anything unexpected happens, make sure we raise
            # a RadioError and log the problem
            LOG.exception('Unexpected error during upload')
            raise errors.RadioError('Unexpected error communicating '
                                    'with the radio')

    def get_memory(self, number):
        """Get the mem representation from the radio image"""
        _mem = self._memobj.memory[number - 1]

        # Create a high-level memory object to return to the UI
        mem = chirp_common.Memory()

        # Memory number
        mem.number = number

        if _mem.get_raw()[:1] == b"\xFF":
            mem.empty = True
            return mem

        # Freq and offset
        mem.freq = int(_mem.rxfreq) * 10
        # tx freq can be blank
        if _mem.txfreq.get_raw() == b"\xFF\xFF\xFF\xFF":
            # TX freq not set
            mem.offset = 0
            mem.duplex = "off"
        else:
            # TX freq set
            offset = (int(_mem.txfreq) * 10) - mem.freq
            if offset != 0:
                if _split(self.get_features(), mem.freq, int(
                          _mem.txfreq) * 10):
                    mem.duplex = "split"
                    mem.offset = int(_mem.txfreq) * 10
                elif offset < 0:
                    mem.offset = abs(offset)
                    mem.duplex = "-"
                elif offset > 0:
                    mem.offset = offset
                    mem.duplex = "+"
            else:
                mem.offset = 0

        for char in _mem.name:
            if str(char) == "\xFF":
                char = " "  # may have 0xFF mid-name
            mem.name += str(char)
        mem.name = mem.name.rstrip()

        dtcs_pol = ["N", "N"]

        if _mem.txtone in [0, 0xFFFF]:
            txmode = ""
        elif _mem.txtone >= 0x0258:
            txmode = "Tone"
            mem.rtone = int(_mem.txtone) / 10.0
        elif _mem.txtone <= 0x0258:
            txmode = "DTCS"
            if _mem.txtone > 0x69:
                index = _mem.txtone - 0x6A
                dtcs_pol[0] = "R"
            else:
                index = _mem.txtone - 1
            mem.dtcs = DTCS[index]
        else:
            LOG.warn("Bug: txtone is %04x" % _mem.txtone)

        if _mem.rxtone in [0, 0xFFFF]:
            rxmode = ""
        elif _mem.rxtone >= 0x0258:
            rxmode = "Tone"
            mem.ctone = int(_mem.rxtone) / 10.0
        elif _mem.rxtone <= 0x0258:
            rxmode = "DTCS"
            if _mem.rxtone >= 0x6A:
                index = _mem.rxtone - 0x6A
                dtcs_pol[1] = "R"
            else:
                index = _mem.rxtone - 1
            mem.rx_dtcs = DTCS[index]
        else:
            LOG.warn("Bug: rxtone is %04x" % _mem.rxtone)

        if txmode == "Tone" and not rxmode:
            mem.tmode = "Tone"
        elif txmode == rxmode and txmode == "Tone" and mem.rtone == mem.ctone:
            mem.tmode = "TSQL"
        elif txmode == rxmode and txmode == "DTCS" and mem.dtcs == mem.rx_dtcs:
            mem.tmode = "DTCS"
        elif rxmode or txmode:
            mem.tmode = "Cross"
            mem.cross_mode = "%s->%s" % (txmode, rxmode)

        mem.dtcs_polarity = "".join(dtcs_pol)

        if not _mem.scan:
            mem.skip = "S"

        _levels = self.POWER_LEVELS
        if self.MODEL in ["A36plus", "A36plus_8w", "UV-A37", "AR-730"]:
            if _mem.txpower == TXPOWER_HIGH:
                mem.power = _levels[0]
            elif _mem.txpower == TXPOWER_LOW:
                mem.power = _levels[1]
            else:
                LOG.error('%s: get_mem: unhandled power level: 0x%02x' %
                          (mem.name, _mem.txpower))
        else:
            if _mem.txpower == TXPOWER_HIGH:
                mem.power = _levels[0]
            elif _mem.txpower == TXPOWER_MID:
                mem.power = _levels[1]
            elif _mem.txpower == TXPOWER_LOW:
                mem.power = _levels[2]
            else:
                LOG.error('%s: get_mem: unhandled power level: 0x%02x' %
                          (mem.name, _mem.txpower))

        mem.mode = _mem.narrow and "NFM" or "FM"

        mem.extra = RadioSettingGroup("Extra", "extra")

        # BCL (Busy Channel Lockout)
        rs = RadioSettingValueBoolean(_mem.bcl)
        rset = RadioSetting("bcl", "BCL", rs)
        mem.extra.append(rset)

        # PTT-ID
        rs = RadioSettingValueList(PTTID_LIST, PTTID_LIST[_mem.pttid])
        rset = RadioSetting("pttid", "PTT ID", rs)
        mem.extra.append(rset)

        # Signal (DTMF Encoder Group #)
        rs = RadioSettingValueList(PTTIDCODE_LIST, PTTIDCODE_LIST[_mem.scode])
        rset = RadioSetting("scode", "PTT ID Code", rs)
        mem.extra.append(rset)

        return mem

    def set_memory(self, mem):
        _mem = self._memobj.memory[mem.number - 1]

        if mem.empty:
            _mem.set_raw("\xff" * 32)
            return

        _mem.set_raw("\x00" * 16 + "\xFF" * 16)

        _mem.rxfreq = mem.freq / 10

        if mem.duplex == "off":
            _mem.txfreq.fill_raw(b"\xFF")
        elif mem.duplex == "split":
            _mem.txfreq = mem.offset / 10
        elif mem.duplex == "+":
            _mem.txfreq = (mem.freq + mem.offset) / 10
        elif mem.duplex == "-":
            _mem.txfreq = (mem.freq - mem.offset) / 10
        else:
            _mem.txfreq = mem.freq / 10

        _namelength = self.get_features().valid_name_length
        for i in range(_namelength):
            try:
                _mem.name[i] = mem.name[i]
            except IndexError:
                _mem.name[i] = "\xFF"

        rxmode = txmode = ""
        if mem.tmode == "Tone":
            _mem.txtone = int(mem.rtone * 10)
            _mem.rxtone = 0
        elif mem.tmode == "TSQL":
            _mem.txtone = int(mem.ctone * 10)
            _mem.rxtone = int(mem.ctone * 10)
        elif mem.tmode == "DTCS":
            rxmode = txmode = "DTCS"
            _mem.txtone = DTCS.index(mem.dtcs) + 1
            _mem.rxtone = DTCS.index(mem.dtcs) + 1
        elif mem.tmode == "Cross":
            txmode, rxmode = mem.cross_mode.split("->", 1)
            if txmode == "Tone":
                _mem.txtone = int(mem.rtone * 10)
            elif txmode == "DTCS":
                _mem.txtone = DTCS.index(mem.dtcs) + 1
            else:
                _mem.txtone = 0
            if rxmode == "Tone":
                _mem.rxtone = int(mem.ctone * 10)
            elif rxmode == "DTCS":
                _mem.rxtone = DTCS.index(mem.rx_dtcs) + 1
            else:
                _mem.rxtone = 0
        else:
            _mem.rxtone = 0
            _mem.txtone = 0

        if txmode == "DTCS" and mem.dtcs_polarity[0] == "R":
            _mem.txtone += 0x69
        if rxmode == "DTCS" and mem.dtcs_polarity[1] == "R":
            _mem.rxtone += 0x69

        _mem.scan = mem.skip != "S"
        _mem.narrow = mem.mode == "NFM"

        _levels = self.POWER_LEVELS
        if self.MODEL in ["A36plus", "A36plus_8w", "UV-A37", "AR-730"]:
            if mem.power is None:
                _mem.txpower = TXPOWER_HIGH
            elif mem.power == _levels[0]:
                _mem.txpower = TXPOWER_HIGH
            elif mem.power == _levels[1]:
                _mem.txpower = TXPOWER_LOW
            else:
                LOG.error('%s: set_mem: unhandled power level: %s' %
                          (mem.name, mem.power))
        else:
            if mem.power is None:
                _mem.txpower = TXPOWER_HIGH
            elif mem.power == _levels[0]:
                _mem.txpower = TXPOWER_HIGH
            elif mem.power == _levels[1]:
                _mem.txpower = TXPOWER_MID
            elif mem.power == _levels[2]:
                _mem.txpower = TXPOWER_LOW
            else:
                LOG.error('%s: set_mem: unhandled power level: %s' %
                          (mem.name, mem.power))

        for setting in mem.extra:
            if setting.get_name() == "scramble_type":
                setattr(_mem, setting.get_name(), int(setting.value) + 8)
                setattr(_mem, "scramble_type2", int(setting.value) + 8)
            else:
                setattr(_mem, setting.get_name(), setting.value)

    def get_settings(self):
        _dtmf = self._memobj.dtmf
        _settings = self._memobj.settings
        basic = RadioSettingGroup("basic", "Basic Settings")
        group = RadioSettings(basic)

        # Menu 12: TOT
        rs = RadioSettingValueList(TOT_LIST, TOT_LIST[_settings.tot])
        rset = RadioSetting("tot", "Time Out Timer", rs)
        basic.append(rset)

        # Menu 00: SQL
        rs = RadioSettingValueInteger(0, 9, _settings.sql)
        rset = RadioSetting("sql", "Squelch Level", rs)
        basic.append(rset)

        # Menu 13: VOX
        rs = RadioSettingValueList(OFF1TO9_LIST, OFF1TO9_LIST[_settings.vox])
        rset = RadioSetting("vox", "VOX", rs)
        basic.append(rset)

        # Menu 39: VOX DELAY
        rs = RadioSettingValueList(VOXD_LIST, VOXD_LIST[_settings.voxd])
        rset = RadioSetting("voxd", "VOX Delay", rs)
        basic.append(rset)

        # Menu 15: VOICE
        rs = RadioSettingValueBoolean(_settings.voice)
        rset = RadioSetting("voice", "Voice Prompts", rs)
        basic.append(rset)

        if self.MODEL not in ["A36plus", "A36plus_8w", "UV-A37", "AR-730"]:
            # Menu 17: LANGUAGE
            rs = RadioSettingValueList(LANGUAGE_LIST,
                                       LANGUAGE_LIST[_settings.language])
            rset = RadioSetting("language", "Voice", rs)
            basic.append(rset)

        # Menu 23: ABR
        rs = RadioSettingValueList(ABR_LIST, ABR_LIST[_settings.abr])
        rset = RadioSetting("abr", "Auto BackLight", rs)
        basic.append(rset)

        # Work Mode A
        rs = RadioSettingValueList(WORKMODE_LIST,
                                   WORKMODE_LIST[_settings.vfomra])
        rset = RadioSetting("vfomra", "Work Mode A", rs)
        basic.append(rset)

        # Work Mode B
        rs = RadioSettingValueList(WORKMODE_LIST,
                                   WORKMODE_LIST[_settings.vfomrb])
        rset = RadioSetting("vfomrb", "Work Mode B", rs)
        basic.append(rset)

        # Menu 19: SC-REV
        rs = RadioSettingValueList(SCREV_LIST, SCREV_LIST[_settings.screv])
        rset = RadioSetting("screv", "Scan Resume Method", rs)
        basic.append(rset)

        # Menu 10: SAVE
        rs = RadioSettingValueList(SAVE_LIST,
                                   SAVE_LIST[_settings.save])
        rset = RadioSetting("save", "Battery Save Mode", rs)
        basic.append(rset)

        # Menu 42: MDF-A
        rs = RadioSettingValueList(MDF_LIST, MDF_LIST[_settings.mdfa])
        rset = RadioSetting("mdfa", "Memory Display Format A", rs)
        basic.append(rset)

        # Menu 43: MDF-B
        rs = RadioSettingValueList(MDF_LIST, MDF_LIST[_settings.mdfb])
        rset = RadioSetting("mdfb", "Memory Display Format B", rs)
        basic.append(rset)

        # Menu 33: DTMFST (DTMF ST)
        rs = RadioSettingValueList(DTMFST_LIST, DTMFST_LIST[_settings.dtmfst])
        rset = RadioSetting("dtmfst", "DTMF Side Tone", rs)
        basic.append(rset)

        # Menu 37: PTT-LT
        rs = RadioSettingValueList(PTTLT_LIST, PTTLT_LIST[_settings.pttlt])
        rset = RadioSetting("pttlt", "PTT Delay", rs)
        basic.append(rset)

        rs = RadioSettingValueInteger(1, 60, _settings.ani + 1)
        rset = RadioSetting("ani", "ANI", rs)
        basic.append(rset)

        # Menu 20: PF2
        def apply_skey2s_listvalue(setting, obj):
            LOG.debug("Setting value: " + str(setting.value) + " from list")
            val = str(setting.value)
            index = SKEY2S_CHOICES.index(val)
            val = SKEY2S_VALUES[index]
            obj.set_value(val)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
            unwanted = [9, 10, 11, 12]
        elif self.MODEL in ["UV-A37", "AR-730"]:
            unwanted = [0, 5, 7, 9, 10, 11, 12]
        elif self.MODEL in ["A36plus", "A36plus_8w"]:
            unwanted = [0, 5, 7, 9, 10, 11]
        else:
            unwanted = []
        SKEY2S_CHOICES = ALL_SKEY_CHOICES.copy()
        SKEY2S_VALUES = ALL_SKEY_VALUES.copy()
        for ele in sorted(unwanted, reverse=True):
            del SKEY2S_CHOICES[ele]
            del SKEY2S_VALUES[ele]

        if _settings.skey2_sp in SKEY2S_VALUES:
            idx = SKEY2S_VALUES.index(_settings.skey2_sp)
        else:
            idx = SKEY2S_VALUES.index(0x07)  # default FM
        rs = RadioSettingValueList(SKEY2S_CHOICES, SKEY2S_CHOICES[idx])
        rset = RadioSetting("skey2_sp", "PF2 Key (Short Press)", rs)
        rset.set_apply_callback(apply_skey2s_listvalue, _settings.skey2_sp)
        basic.append(rset)

        # Menu 21: PF2 LONG PRESS
        def apply_skey2l_listvalue(setting, obj):
            LOG.debug("Setting value: " + str(setting.value) + " from list")
            val = str(setting.value)
            index = SKEY2L_CHOICES.index(val)
            val = SKEY2L_VALUES[index]
            obj.set_value(val)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
            unwanted = [8, 9, 10, 11, 12]
        elif self.MODEL in ["UV-A37", "AR-730"]:
            unwanted = [0, 5, 7, 8, 10, 11, 12]
        elif self.MODEL in ["A36plus", "A36plus_8w"]:
            unwanted = [0, 5, 7, 8, 11, 12]
        else:
            unwanted = []
        SKEY2L_CHOICES = ALL_SKEY_CHOICES.copy()
        SKEY2L_VALUES = ALL_SKEY_VALUES.copy()
        for ele in sorted(unwanted, reverse=True):
            del SKEY2L_CHOICES[ele]
            del SKEY2L_VALUES[ele]

        if _settings.skey2_lp in SKEY2L_VALUES:
            idx = SKEY2L_VALUES.index(_settings.skey2_lp)
        else:
            idx = SKEY2L_VALUES.index(0x1D)  # default Search
        rs = RadioSettingValueList(SKEY2L_CHOICES, SKEY2L_CHOICES[idx])
        rset = RadioSetting("skey2_lp", "PF2 Key (Long Press)", rs)
        rset.set_apply_callback(apply_skey2l_listvalue, _settings.skey2_lp)
        basic.append(rset)

        # Menu 22: PF3
        def apply_skey3s_listvalue(setting, obj):
            LOG.debug("Setting value: " + str(setting.value) + " from list")
            val = str(setting.value)
            index = SKEY3S_CHOICES.index(val)
            val = SKEY3S_VALUES[index]
            obj.set_value(val)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
            unwanted = [8, 9, 10, 11, 12]
        elif self.MODEL in ["UV-A37", "AR-730"]:
            unwanted = [0, 5, 7, 8, 9, 10, 11, 12]
        elif self.MODEL in ["A36plus", "A36plus_8w"]:
            unwanted = [0, 5, 7, 8, 11]
        else:
            unwanted = []
        SKEY3S_CHOICES = ALL_SKEY_CHOICES.copy()
        SKEY3S_VALUES = ALL_SKEY_VALUES.copy()
        for ele in sorted(unwanted, reverse=True):
            del SKEY3S_CHOICES[ele]
            del SKEY3S_VALUES[ele]

        if _settings.skey3_sp in SKEY3S_VALUES:
            idx = SKEY3S_VALUES.index(_settings.skey3_sp)
        else:
            idx = SKEY3S_VALUES.index(0x0C)  # default NOAA
        rs = RadioSettingValueList(SKEY3S_CHOICES, SKEY3S_CHOICES[idx])
        rset = RadioSetting("skey3_sp", "PF3 Key (Short Press)", rs)
        rset.set_apply_callback(apply_skey3s_listvalue, _settings.skey3_sp)
        basic.append(rset)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
            # Menu 24: PF3 LONG PRESS (RT-470L)
            def apply_skey3l_listvalue(setting, obj):
                LOG.debug("Setting value: " + str(setting.value) +
                          " from list")
                val = str(setting.value)
                index = SKEY3L_CHOICES.index(val)
                val = SKEY2L_VALUES[index]
                obj.set_value(val)

            if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
                unwanted = [8, 9, 10, 11, 12]
            else:
                unwanted = []
            SKEY3L_CHOICES = ALL_SKEY_CHOICES.copy()
            SKEY3L_VALUES = ALL_SKEY_VALUES.copy()
            for ele in sorted(unwanted, reverse=True):
                del SKEY3L_CHOICES[ele]
                del SKEY3L_VALUES[ele]

            if _settings.skey3_lp in SKEY3L_VALUES:
                idx = SKEY3L_VALUES.index(_settings.skey3_lp)
            else:
                idx = SKEY3L_VALUES.index(0x1D)  # default SEARCH
            rs = RadioSettingValueList(SKEY3L_CHOICES, SKEY3L_CHOICES[idx])
            rset = RadioSetting("skey3_lp", "PF3 Key (Long Press)", rs)
            rset.set_apply_callback(apply_skey3l_listvalue,
                                    _settings.skey3_lp)
            basic.append(rset)

        # Menu 25: TOP KEY (RT-470L)
        def apply_skeytop_listvalue(setting, obj):
            LOG.debug("Setting value: " + str(setting.value) +
                      " from list")
            val = str(setting.value)
            index = SKEYTOP_CHOICES.index(val)
            val = SKEYTOP_VALUES[index]
            obj.set_value(val)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X", "RT-470"]:
            unwanted = [8, 9, 10, 11, 12]
        elif self.MODEL in ["UV-A37", "AR-730"]:
            unwanted = [0, 5, 7, 8, 9, 10, 11, 12]
        elif self.MODEL in ["A36plus", "A36plus_8w"]:
            unwanted = [0, 5, 7, 8, 11]
        else:
            unwanted = []
        SKEYTOP_CHOICES = ALL_SKEY_CHOICES.copy()
        SKEYTOP_VALUES = ALL_SKEY_VALUES.copy()
        for ele in sorted(unwanted, reverse=True):
            del SKEYTOP_CHOICES[ele]
            del SKEYTOP_VALUES[ele]

        if _settings.topkey_sp in SKEYTOP_VALUES:
            idx = SKEYTOP_VALUES.index(_settings.topkey_sp)
        else:
            idx = SKEYTOP_VALUES.index(0x1D)  # default SEARCH
        rs = RadioSettingValueList(SKEYTOP_CHOICES, SKEYTOP_CHOICES[idx])
        rset = RadioSetting("topkey_sp", "Top Key (Short Press)", rs)
        rset.set_apply_callback(apply_skeytop_listvalue,
                                _settings.topkey_sp)
        basic.append(rset)

        # Mneu 36: TONE
        rs = RadioSettingValueList(TONE_LIST, TONE_LIST[_settings.tone])
        rset = RadioSetting("tone", "Tone-burst Frequency", rs)
        basic.append(rset)

        # Mneu 29: POWER ON MSG
        rs = RadioSettingValueList(PONMSG_LIST, PONMSG_LIST[_settings.ponmsg])
        rset = RadioSetting("ponmsg", "Power On Message", rs)
        basic.append(rset)

        if self.MODEL in ["HI-8811", "RT-470L", "RT-470X"]:
            rs = RadioSettingValueList(TAILCODE_LIST,
                                       TAILCODE_LIST[_settings.tailcode])
            rset = RadioSetting("tailcode", "Tail Code", rs)
            basic.append(rset)

        # Menu 46: STE
        rs = RadioSettingValueBoolean(_settings.ste)
        rset = RadioSetting("ste", "Squelch Tail Eliminate (HT to HT)", rs)
        basic.append(rset)

        # Menu 40: RP-STE
        rs = RadioSettingValueList(RPSTE_LIST, RPSTE_LIST[_settings.rpste])
        rset = RadioSetting("rpste", "Squelch Tail Eliminate (repeater)", rs)
        basic.append(rset)

        # Menu 41: RPT-RL
        rs = RadioSettingValueList(RPSTE_LIST, RPSTE_LIST[_settings.rptrl])
        rset = RadioSetting("rptrl", "STE Repeater Delay", rs)
        basic.append(rset)

        # Menu 38: MENU EXIT TIME
        rs = RadioSettingValueList(MENUQUIT_LIST,
                                   MENUQUIT_LIST[_settings.menuquit])
        rset = RadioSetting("menuquit", "Menu Auto Quit", rs)
        basic.append(rset)

        # Menu 34: AUTOLOCK
        rs = RadioSettingValueList(AUTOLK_LIST, AUTOLK_LIST[_settings.autolk])
        rset = RadioSetting("autolk", "Key Auto Lock", rs)
        basic.append(rset)

        # Menu 28: CDCSS SAVE MODE
        rs = RadioSettingValueList(QTSAVE_LIST, QTSAVE_LIST[_settings.qtsave])
        rset = RadioSetting("qtsave", "QT Save Type", rs)
        basic.append(rset)

        # Menu 45: TX-A/B
        rs = RadioSettingValueList(DUALTX_LIST, DUALTX_LIST[_settings.dualtx])
        rset = RadioSetting("dualtx", "Dual TX", rs)
        basic.append(rset)

        # Menu 47: AL-MODE
        rs = RadioSettingValueList(ALMODE_LIST, ALMODE_LIST[_settings.almode])
        rset = RadioSetting("almode", "Alarm Mode", rs)
        basic.append(rset)

        # Menu 11: ROGER
        # ==========
        # Notice to developers:
        # The RT-470 v1.22 firmware expanded the ROGER menu with an additional
        # choice, 'TONE1200'. RT-470 radios with a firmware version prior to
        #  v1.22 will not honor the ROGER menu's 'TONE1200' choice in CHIRP.
        # ==========
        rs = RadioSettingValueList(ROGER_LIST, ROGER_LIST[_settings.roger])
        rset = RadioSetting("roger", "Roger", rs)
        basic.append(rset)

        rs = RadioSettingValueBoolean(_settings.alarmsound)
        rset = RadioSetting("alarmsound", "Alarm Sound", rs)
        basic.append(rset)

        # Menu 44: TDR
        rs = RadioSettingValueBoolean(_settings.tdr)
        rset = RadioSetting("tdr", "TDR", rs)
        basic.append(rset)

        rs = RadioSettingValueBoolean(not _settings.fmradio)
        rset = RadioSetting("fmradio", "FM Radio", rs)
        basic.append(rset)

        rs = RadioSettingValueBoolean(_settings.kblock)
        rset = RadioSetting("kblock", "KB Lock", rs)
        basic.append(rset)

        # Menu 16: BEEP PROMPT
        rs = RadioSettingValueBoolean(_settings.beep)
        rset = RadioSetting("beep", "Beep", rs)
        basic.append(rset)

        if self.MODEL not in ["A36plus", "A36plus_8w", "UV-A37", "AR-730"]:
            # Menu 48: RX END TAIL
            rs = RadioSettingValueList(TONERXEND_LIST,
                                       TONERXEND_LIST[_settings.rxendtail])
            rset = RadioSetting("rxendtail", "Tone RX End", rs)
            basic.append(rset)

        dtmf = RadioSettingGroup("dtmf", "DTMF Settings")
        group.append(dtmf)

        def apply_code(setting, obj, length):
            code = []
            for j in range(0, length):
                try:
                    code.append(DTMF_CHARS.index(str(setting.value)[j]))
                except IndexError:
                    code.append(0xFF)
            obj.code = code

        for i in range(0, 15):
            _codeobj = self._memobj.pttid[i].code
            _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
            rs = RadioSettingValueString(0, 5, _code, False)
            rs.set_charset(DTMF_CHARS)
            rset = RadioSetting("pttid/%i.code" % i,
                                "PTT-ID Code %i" % (i + 1), rs)
            rset.set_apply_callback(apply_code, self._memobj.pttid[i], 5)
            dtmf.append(rset)

        rs = RadioSettingValueList(DTMFSPEED_LIST,
                                   DTMFSPEED_LIST[_dtmf.dtmfon])
        rset = RadioSetting("dtmf.dtmfon", "DTMF Speed (on)", rs)
        dtmf.append(rset)

        rs = RadioSettingValueList(DTMFSPEED_LIST,
                                   DTMFSPEED_LIST[_dtmf.dtmfoff])
        rset = RadioSetting("dtmf.dtmfoff", "DTMF Speed (off)", rs)
        dtmf.append(rset)

        rs = RadioSettingValueList(PTTID_LIST, PTTID_LIST[_settings.pttid])
        rset = RadioSetting("pttid", "PTT ID", rs)
        dtmf.append(rset)

        ani = RadioSettingGroup("ani", "ANI Code List Settings")
        group.append(ani)

        def _filter(name):
            filtered = ""
            for char in str(name):
                if char in self._valid_chars:
                    filtered += char
                else:
                    filtered += " "
            return filtered

        end = 60 - self._aninames  # end of immutable ANI names
        for i in range(0, end):
            _codeobj = self._memobj.anicodes[i].code
            _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
            rs = RadioSettingValueString(0, 3, _code, False)
            rs.set_charset(DTMF_CHARS)
            rset = RadioSetting("anicodes/%i.code" % i,
                                "ANI Code %i (NUM.%i)" % (i + 1, i + 1), rs)
            rset.set_apply_callback(apply_code, self._memobj.anicodes[i], 3)
            ani.append(rset)

        for i in range(end, 60):
            _codeobj = self._memobj.anicodes[i].code
            _code = "".join([DTMF_CHARS[x] for x in _codeobj if int(x) < 0x1F])
            rs = RadioSettingValueString(0, 3, _code, False)
            rs.set_charset(DTMF_CHARS)
            rset = RadioSetting("anicodes/%i.code" % (i),
                                "ANI Code %i" % (i + 1), rs)
            rset.set_apply_callback(apply_code,
                                    self._memobj.anicodes[i], 3)
            ani.append(rset)

            _nameobj = self._memobj.aninames[i - end].name
            rs = RadioSettingValueString(0, 10, _filter(_nameobj))
            rset = RadioSetting("aninames/%i.name" % (i - end),
                                "ANI Code %i Name" % (i + 1), rs)
            ani.append(rset)

        if self.MODEL in ["A36plus", "A36plus_8w"]:
            custom = RadioSettingGroup("custom", "Custom Channel Names")
            group.append(custom)

            for i in range(0, 30):
                _nameobj = self._memobj.customnames[i].name
                rs = RadioSettingValueString(0, 10, _filter(_nameobj))
                rset = RadioSetting("customnames/%i.name" % i,
                                    "Custom Name %i" % (i + 1), rs)
                custom.append(rset)

        if self.MODEL in ["A36plus", "A36plus_8w"]:
            # Menu 21: RX END TAIL
            rs = RadioSettingValueList(TONERXEND_LIST,
                                       TONERXEND_LIST[_settings.skey3_lp])
            rset = RadioSetting("skey3_lp", "RX End Tail", rs)
            basic.append(rset)

            # Menu 23: TAIL PHASE
            rs = RadioSettingValueList(TAILPHASE_LIST,
                                       TAILPHASE_LIST[_settings.rxendtail])
            rset = RadioSetting("rxendtail", "Tail Phase", rs)
            basic.append(rset)

        return group

    def set_settings(self, settings):
        _settings = self._memobj.settings
        for element in settings:
            if not isinstance(element, RadioSetting):
                self.set_settings(element)
                continue
            else:
                try:
                    name = element.get_name()
                    if "." in name:
                        bits = name.split(".")
                        obj = self._memobj
                        for bit in bits[:-1]:
                            if "/" in bit:
                                bit, index = bit.split("/", 1)
                                index = int(index)
                                obj = getattr(obj, bit)[index]
                            else:
                                obj = getattr(obj, bit)
                        setting = bits[-1]
                    else:
                        obj = _settings
                        setting = element.get_name()

                    if element.has_apply_callback():
                        LOG.debug("Using apply callback")
                        element.run_apply_callback()
                    elif setting == "ani":
                        setattr(obj, setting, int(element.value) - 1)
                    elif setting == "fmradio":
                        setattr(obj, setting, not int(element.value))
                    elif element.value.get_mutable():
                        LOG.debug("Setting %s = %s" % (setting, element.value))
                        setattr(obj, setting, element.value)
                except Exception as e:
                    LOG.debug(element.get_name(), e)
                    raise

    @classmethod
    def match_model(cls, filedata, filename):
        # This radio has always been post-metadata, so never do
        # old-school detection
        return False


@directory.register
class RT470Radio(JC8810base):
    """Radtel RT-470"""
    VENDOR = "Radtel"
    MODEL = "RT-470"

    # ==========
    # Notice to developers:
    # The RT-470 support in this driver is currently based upon...
    # - v1.25a firmware (original pcb)
    # - v2.11a firmware (pcb2)
    # ==========

    # original pcb
    _fingerprint_pcb1 = [b"\x00\x00\x00\x26\x00\x20\xD8\x04",
                         b"\x00\x00\x00\x42\x00\x20\xF0\x04",
                         b"\x00\x00\x00\x4A\x00\x20\xF8\x04",
                         b"\x00\x00\x00\x3A\x00\x20\xE8\x04",  # fw 1.25A
                         ]

    # pcb 2
    _fingerprint_pcb2 = [b"\x00\x00\x00\x2C\x00\x20\xD8\x04",  # fw v2.11A
                         ]

    _fingerprint = _fingerprint_pcb1 + _fingerprint_pcb2

    VALID_BANDS = [(16000000, 100000000),
                   (100000000, 136000000),
                   (136000000, 200000000),
                   (200000000, 300000000),
                   (300000000, 400000000),
                   (400000000, 560000000),
                   (740000000, 1000000000),
                   ]


@directory.register
class RT470LRadio(JC8810base):
    """Radtel RT-470L"""
    VENDOR = "Radtel"
    MODEL = "RT-470L"

    # ==========
    # Notice to developers:
    # The RT-470 support in this driver is currently based upon v1.17 firmware.
    # ==========

    _fingerprint = [b"\x00\x00\x00\xfe\x00\x20\xAC\x04",
                    b"\x00\x00\x00\x20\x00\x20\xCC\x04",
                    b"\x00\x00\x00\x20\x00\x20\x07\x00"]

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=5.00),
                    chirp_common.PowerLevel("M", watts=4.00),
                    chirp_common.PowerLevel("L", watts=2.00)]

    VALID_BANDS = [(108000000, 136000000),
                   (136000000, 179000000),
                   (220000000, 260000000),
                   (330000000, 400000000),
                   (400000000, 520000000)]


@directory.register
class RT470XRadio(RT470LRadio):
    """Radtel RT-470X"""
    VENDOR = "Radtel"
    MODEL = "RT-470X"

    # ==========
    # Notice to developers:
    # The RT-470X support in this driver is currently based upon...
    # - v1.18a firmware (original pcb)
    # - v2.13a firmware (pcb2)
    # ==========

    # original pcb
    _fingerprint_pcb1 = [b"\x00\x00\x00\x20\x00\x20\xCC\x04",
                         ]

    # pcb 2
    _fingerprint_pcb2 = [b"\x00\x00\x00\x2C\x00\x20\xD8\x04",  # fw v2.10A
                         b"\x00\x00\x00\x36\x00\x20\xDC\x04",  # fw v2.13A
                         ]

    _fingerprint = _fingerprint_pcb1 + _fingerprint_pcb2

    RT470X_ORIG = False

    VALID_BANDS = [(100000000, 136000000),
                   (136000000, 200000000),
                   (200000000, 300000000),
                   (300000000, 400000000),
                   (400000000, 560000000)]


@directory.register
class HI8811Radio(RT470LRadio):
    """Hiroyasu HI-8811"""
    VENDOR = "Hiroyasu"
    MODEL = "HI-8811"

    # ==========
    # Notice to developers:
    # The HI-8811 support in this driver is currently based upon...
    # - v1.17 firmware (original pcb)
    # - v2.00 firmware (pcb2)
    # ==========

    # original pcb
    _fingerprint_pcb1 = [b"\x00\x00\x00\xfe\x00\x20\xAC\x04",
                         b"\x00\x00\x00\x20\x00\x20\xCC\x04",  # fw v1.17
                         b"\x00\x00\x00\x20\x00\x20\x07\x00",
                         ]

    # pcb 2
    _fingerprint_pcb2 = [b"\x00\x00\x00\x28\x00\x20\xD4\x04",  # fw v2.00
                         b"\x00\x00\x00\x28\x00\x20\x07\x00",  # fw v2.00
                         ]

    _fingerprint = _fingerprint_pcb1 + _fingerprint_pcb2


@directory.register
class UVA37Radio(JC8810base):
    """Anysecu UV-A37"""
    VENDOR = "Anysecu"
    MODEL = "UV-A37"

    # ==========
    # Notice to developers:
    # The UV-A37 support in this driver is currently based upon v1.24
    # firmware.
    # ==========

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=5.00),
                    chirp_common.PowerLevel("L", watts=1.00)]

    VALID_BANDS = [(108000000, 136000000),
                   (136000000, 174000000),
                   (200000000, 260000000),
                   (350000000, 390000000),
                   (400000000, 520000000)]

    _magic = b"PROGRAMJC37U"
    _fingerprint = [b"\x00\x00\x00\xE4\x00\x20\x94\x04",
                    b"\x00\x00\x00\xE8\x00\x20\x98\x04"]

    _ranges = [
               (0x0000, 0x2000),
               (0x8000, 0x8040),
               (0x9000, 0x9040),
               (0xA000, 0xA140),
               (0xB000, 0xB440)
              ]
    _memsize = 0xB440


@directory.register
class A36plusRadio(JC8810base):
    """Talkpod A36plus"""
    VENDOR = "Talkpod"
    MODEL = "A36plus"

    # ==========
    # Notice to developers:
    # The A36plus support in this driver is currently based upon v1.22
    # firmware.
    # ==========

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=5.00),
                    chirp_common.PowerLevel("L", watts=1.00)]

    VALID_BANDS = [(108000000, 136000000),
                   (136000000, 180000000),
                   (200000000, 260000000),
                   (350000000, 400000000),
                   (400000000, 520000000),
                   ]

    _magic = b"PROGRAMJC37U"
    _fingerprint = [b"\x00\x00\x00\x42\x00\x20\xF0\x04",
                    b"\x00\x00\x00\x5A\x00\x20\x08\x05",  # fw 1.18
                    b"\x00\x00\x00\x9E\x00\x20\x0C\x05",  # fw 1.22
                    b"\x00\x00\x00\xFA\x00\x20\x40\x05",  # fw 1.4
                    ]

    _ranges = [
               (0x0000, 0x4000),
               (0x8000, 0x8040),
               (0x9000, 0x9040),
               (0xA000, 0xA140),
               (0xB000, 0xB440)
              ]
    _memsize = 0xB440
    _upper = 512  # fw 1.22 expands from 256 to 512 channels
    _aninames = 10
    _mem_params = (_upper,  # number of channels
                   _aninames,  # number of aninames
                   )

    def process_mmap(self):
        mem_format = MEM_FORMAT % self._mem_params + MEM_FORMAT_A36PLUS
        self._memobj = bitwise.parse(mem_format, self._mmap)


@directory.register
class A36plus8wRadio(A36plusRadio):
    """Talkpod A36plus8w"""
    VENDOR = "Talkpod"
    MODEL = "A36plus_8w"

    # ==========
    # Notice to developers:
    # The A36plus 8w support in this driver is currently based upon v1.4
    # firmware.
    # ==========

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=8.00),
                    chirp_common.PowerLevel("L", watts=1.00)]

    _fingerprint = [b"\x00\x00\x00\xFA\x00\x20\x40\x05",  # fw 1.4
                    ]


@directory.register
class AR730Radio(UVA37Radio):
    """Abbree AR730"""
    VENDOR = "Abbree"
    MODEL = "AR-730"

    # ==========
    # Notice to developers:
    # The AR-730 support in this driver is currently based upon v1.24
    # firmware.
    # ==========

    POWER_LEVELS = [chirp_common.PowerLevel("H", watts=5.00),
                    chirp_common.PowerLevel("L", watts=1.00)]

    VALID_BANDS = [(108000000, 136000000),
                   (136000000, 180000000),
                   (200000000, 260000000),
                   (350000000, 390000000),
                   (400000000, 520000000)]
