# Copyright 2016 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 time
import os
import struct
import re
import logging

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

LOG = logging.getLogger(__name__)

MEM_FORMAT = """
struct memory {
  lbcd rxfreq[4];
  lbcd txfreq[4];
  lbcd rxtone[2];
  lbcd txtone[2];
  u8 unknown1;
  u8 pttid:2,     // PTT-ID
     unknown2:1,
     signaling:1, // Signaling(ANI)
     unknown3:1,
     bcl:1,       // Busy Channel Lockout
     unknown4:2;
  u8 unknown5:3,
     highpower:1, // Power Level
     isnarrow:1,  // Bandwidth
     scan:1,      // Scan Add
     unknown6:2;
  u8 unknown7;
};

#seekto 0x0010;
struct memory channels[128];

#seekto 0x0810;
struct memory vfo_a;
struct memory vfo_b;

#seekto 0x0830;
struct {
  u8 unknown_0830_1:4,      // 0x0830
     color:2,               // Background Color
     dst:1,                 // DTMF Side Tone
     txsel:1;               // Priority TX Channel Select
  u8 scans:2,               // Scan Mode - 0x0831
     unknown_0831:1,
     autolk:1,              // Auto Key Lock
     save:1,                // Battery Save
     beep:1,                // Key Beep
     voice:2;               // Voice Prompt
  u8 vfomr_fm:1,            // FM Radio Display Mode - 0x0832
     led:2,                 // Background Light
     unknown_0832_2:1,
     dw:1,                  // FM Radio Dual Watch
     name:1,                // Display Names
     vfomr_a:2;             // Display Mode A
  u8 opnset:2,              // Power On Message - 0x0833
     unknown_0833_1:3,
     dwait:1,               // Dual Standby
     vfomr_b:2;             // Display Mode B
  u8 mrcha;                 // mr a ch num - 0x0834
  u8 mrchb;                 // mr b ch num - 0x0835
  u8 fmch;                  // fm radio ch num - 0x0836
  u8 unknown_0837_1:1,      // 0x0837
     ste:1,                 // Squelch Tail Eliminate
     roger:1,               // Roger Beep
     unknown_0837_2:1,
     vox:4;                 // VOX
  u8 step:4,                // Step - 0x0838
     unknown_0838_1:4;
  u8 squelch;               // Squelch - 0x0839
  u8 tot;                   // Time Out Timer - 0x083A
  u8 rptmod:1,              // Repeater Mode - 0x083B
     volmod:2,              // Volume Mode
     rptptt:1,              // Repeater PTT Switch
     rptspk:1,              // Repeater Speaker
     relay:3;               // Cross Band Repeater Enable
  u8 unknown_083C:4,        // 0x083C
     rptrl:4;               // Repeater TX Delay
  u8 pf1:4,                 // Function Key 1 - 0x083D
     pf2:4;                 // Function Key 2
  u8 vot;                   // VOX Delay Time - 0x083E
} settings;

#seekto 0x0848;
struct {
  char line1[7];
} poweron_msg;

struct limit {
  bbcd lower[2];
  bbcd upper[2];
};

#seekto 0x0850;
struct {
  struct limit vhf;
  struct limit uhf;
} limits;

struct fmmemory {
  lbcd fmfreq[4];
};

#seekto 0x085E;
struct fmmemory fmchannels[25];
struct fmmemory fmvfo;

#seekto 0x08D0;
struct {
  char name[7];             // Channel Names
  u8 unknown2[1];
} names[128];

#seekto 0x0D20;
u8 usedflags[16];
u8 scanflags[16];

#seekto 0x0E50;
struct memory rpt_vfo;
struct memory rpt_1;
struct memory rpt_2;
struct memory rpt_3;
struct memory rpt_4;
struct memory rpt_5;

#seekto 0x0EB0;
struct {
    u8 unknown:2,
       rpt_5_enable:1,
       rpt_4_enable:1,
       rpt_3_enable:1,
       rpt_2_enable:1,
       rpt_1_enable:1,
       rpt_vfo_enable:1;
} special_enables;

#seekto 0x0FA0;
struct {
  u8 unknown_0FA0_1:4,
     dispab:1,              // select a/b
     unknown_0FA0_2:3;
} settings2;
"""

CMD_ACK = "\x06"
BLOCK_SIZE = 0x10

RT23_POWER_LEVELS = [chirp_common.PowerLevel("Low", watts=1.00),
                     chirp_common.PowerLevel("High", watts=2.50)]


RT23_DTCS = sorted(chirp_common.DTCS_CODES + 
                   [17, 50, 55, 135, 217, 254, 305, 645, 765])

RT23_CHARSET = chirp_common.CHARSET_UPPER_NUMERIC + \
    ":;<=>?@ !\"#$%&'()*+,-./"

LIST_SIGNALING = ["No", "DTMF"]
LIST_STEP = ["2.50K", "5.00K", "6.25K", "10.00K", "12,50K", "20.00K", "25.00K", 
             "50.00K"]
####LIST_OFFON = ["OFF", "ON"]
LIST_VOX = ["OFF"] + ["%s" % x for x in range(1, 6)]
LIST_TOT = ["OFF"] + ["%s seconds" % x for x in range(30, 300, 30)]
LIST_COLOR = ["Blue", "Orange", "Purple"]
LIST_VOT = ["0.5S", "1.0S", "1.5S", "2.0S", "3.0S"]
LIST_LED = ["Off", "On", "Auto"]
LIST_VOICE = ["Off", "Chinese", "English"]
LIST_OPNSET = ["Full", "Voltage", "Message"]
LIST_SCANS = ["Time Operated", "Carrier Operated", "Search"]

LIST_RPTRL = ["0.5S", "1.0S", "1.5S", "2.0S", "2.5S", "3.0S", "3.5S", "4.0S", 
              "4.5S"]
LIST_RPTMOD = ["Single", "Double"]
LIST_VOLMOD = ["Off", "Sub", "Main"]
LIST_TXSEL = ["Edit", "Busy"]

LIST_VFOMR = ["VFO", "MR(Frequency)", "MR(Channel #/Name)"]
LIST_VFOMRFM = ["VFO", "Channel"]

LIST_PTTID = ["Off", "BOT", "EOT", "Both"]

LIST_PFKEY = [
    "Radio", 
    "Sub-channel Sent", 
    "Scan", 
    "Alarm", 
    "DTMF", 
    "Squelch Off Momentarily", 
    "Battery Power Indicator",
    "Tone 1750",
    "Tone 2100",
    "Tone 1000",
    "Tone 1450"]

RT23_SPECIAL = ["rpt_vfo", "rpt_1", "rpt_2", "rpt_3", "rpt_4", "rpt_5",
                "vfo_a", "vfo_b"]


def _rt23_enter_programming_mode(radio):
    serial = radio.pipe

    #magic = "PROIUAM"
    try:
        serial.write("PROIUAM")
        #for j in range(0, len(magic)):
        #    time.sleep(0.002)
        #    serial.write(magic[j])
        ack = serial.read(1)
    except:
        raise errors.RadioError("Error communicating with radio")

    if not ack:
        raise errors.RadioError("No response from radio")
    elif ack != CMD_ACK:
        raise errors.RadioError("Radio refused to enter programming mode")

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

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

    try:
        serial.write(CMD_ACK)
        ack = serial.read(1)
    except:
        raise errors.RadioError("Error communicating with radio")

    if ack != CMD_ACK:
        raise errors.RadioError("Radio refused to enter programming mode")


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


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

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

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

        chunk = response[4:]

        cs = 0
        for byte in chunk[:-1]:
            cs += ord(byte)
        if ord(chunk[-1]) != (cs & 0xFF):
            raise Exception("Block failed checksum!")

        block_data = chunk[:-1]
    except:
        raise errors.RadioError("Failed to read block at %04x" % block_addr)

    return block_data


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

    cmd = struct.pack(">cHb", 'W', block_addr, BLOCK_SIZE)
    data = radio.get_mmap()[block_addr:block_addr + BLOCK_SIZE]
    cs = 0
    for byte in data:
        cs += ord(byte)
    data += chr(cs & 0xFF)

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

    try:
        #serial.write(cmd + data)
        for j in range(0, len(cmd)):
            time.sleep(0.002)
            serial.write(cmd[j])
        for j in range(0, len(data)):
            time.sleep(0.002)
            serial.write(data[j])
        if serial.read(1) != CMD_ACK:
            raise Exception("No ACK")
    except:
        raise errors.RadioError("Failed to send block "
                                "to radio at %04x" % block_addr)


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

    data = ""

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

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

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

        ####print "Address: %s" % addr
        block = _rt23_read_block(radio, addr, BLOCK_SIZE)
        if addr == 0 and block.startswith("\xFF" * 6):
            block = "P31183" + "\xFF" * 10
        data += block

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

    ####data += radio.MODEL.ljust(8)

    _rt23_exit_programming_mode(radio)

    return memmap.MemoryMap(data)


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

    _rt23_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, BLOCK_SIZE):
            status.cur = addr + BLOCK_SIZE
            radio.status_fn(status)
            _rt23_write_block(radio, addr, BLOCK_SIZE)

    ####_rt23_exit_programming_mode(radio)


def model_match(cls, data):
    """Match the opened/downloaded image to the correct version"""

    if len(data) == 0x1000:
        rid = data[0x0000:0x0006]
        return rid == "P31183"
    else:
        return False


@directory.register
class RT23Radio(chirp_common.CloneModeRadio):
    """RETEVIS RT23"""
    VENDOR = "Retevis"
    MODEL = "RT23"
    BAUD_RATE = 9600

    _ranges = [
               (0x0000, 0x0EC0),
              ]
    _memsize = 0x1000

    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.valid_name_length = 7
        rf.valid_characters = RT23_CHARSET
        rf.has_name = True
        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 = RT23_POWER_LEVELS
        rf.valid_duplexes = ["", "-", "+", "split", "off"]
        rf.valid_modes = ["FM", "NFM"]  # 25 KHz, 12.5 KHz.
        rf.memory_bounds = (1, 128)
        rf.valid_bands = [
            (136000000, 174000000),
            (400000000, 480000000)]
        rf.valid_special_chans = RT23_SPECIAL

        return rf

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

    def sync_in(self):
        self._mmap = do_download(self)
        self.process_mmap()

    def sync_out(self):
        do_upload(self)

    def get_raw_memory(self, number):
        return repr(self._memobj.memory[number - 1])

    def decode_tone(self, val):
        """Parse the tone data to decode from mem, it returns:
        Mode (''|DTCS|Tone), Value (None|###), Polarity (None,N,R)"""
        if val.get_raw() == "\xFF\xFF":
            return '', None, None

        val = int(val)
        if val >= 12000:
            a = val - 12000
            return 'DTCS', a, 'R'
        elif val >= 8000:
            a = val - 8000
            return 'DTCS', a, 'N'
        else:
            a = val / 10.0
            return 'Tone', a, None

    def encode_tone(self, memval, mode, value, pol):
        """Parse the tone data to encode from UI to mem"""
        if mode == '':
            memval[0].set_raw(0xFF)
            memval[1].set_raw(0xFF)
        elif mode == 'Tone':
            memval.set_value(int(value * 10))
        elif mode == 'DTCS':
            flag = 0x80 if pol == 'N' else 0xC0
            memval.set_value(value)
            memval[1].set_bits(flag)
        else:
            raise Exception("Internal error: invalid mode `%s'" % mode)

    def get_memory(self, number):
        mem = chirp_common.Memory()
        if isinstance(number, str):
            # special channel
            _mem = getattr(self._memobj, number)
            _nam = None
            mem.number = - len(RT23_SPECIAL) + RT23_SPECIAL.index(number)
            mem.extd_number = number
            _scn = None
            _usd = None
            if re.match('^rpt', mem.extd_number):
                _special_enables = self._memobj.special_enables
                isused = getattr(_special_enables,
                                 mem.extd_number + "_enable")
            else:
                isused = True
            isscan = True
        else:
            # regular memory
            _mem = self._memobj.channels[number-1]
            _nam = self._memobj.names[number - 1]
            mem.number = number
            bitpos = (1 << ((number - 1) % 8))
            bytepos = ((number - 1) / 8)
            _scn = self._memobj.scanflags[bytepos]
            _usd = self._memobj.usedflags[bytepos]
            isused = bitpos & int(_usd)
            isscan = bitpos & int(_scn)

        if not isused:
            mem.empty = True
            return mem

        mem.freq = int(_mem.rxfreq) * 10

        # We'll consider any blank (i.e. 0MHz frequency) to be empty
        if mem.freq == 0:
            mem.empty = True
            return mem

        if _mem.rxfreq.get_raw() == "\xFF\xFF\xFF\xFF":
            mem.empty = True
            return mem

        if _mem.get_raw() == ("\xFF" * 16):
            LOG.debug("Initializing empty memory")
            _mem.set_raw("\x00" * 16)

        if int(_mem.rxfreq) == int(_mem.txfreq):
            mem.duplex = ""
            mem.offset = 0
        else:
            mem.duplex = int(_mem.rxfreq) > int(_mem.txfreq) and "-" or "+"
            mem.offset = abs(int(_mem.rxfreq) - int(_mem.txfreq)) * 10

        if _nam:
            for char in _nam.name:
                if str(char) == "\xFF":
                    char = " "
                mem.name += str(char)
            mem.name = mem.name.rstrip()

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

        rxtone = txtone = None
        txtone = self.decode_tone(_mem.txtone)
        rxtone = self.decode_tone(_mem.rxtone)
        chirp_common.split_tone_decode(mem, txtone, rxtone)

        mem.power = RT23_POWER_LEVELS[_mem.highpower]

        if _scn:
            if not isscan:
                mem.skip = "S"

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

        rs = RadioSetting("bcl", "BCL",
                          RadioSettingValueBoolean(_mem.bcl))
        mem.extra.append(rs)

        rs = RadioSetting("pttid", "PTT ID",
                          RadioSettingValueList(
                              LIST_PTTID, LIST_PTTID[_mem.pttid]))
        mem.extra.append(rs)

        rs = RadioSetting("signaling", "Optional Signaling",
                          RadioSettingValueList(LIST_SIGNALING,
                              LIST_SIGNALING[_mem.signaling]))
        mem.extra.append(rs)

        return mem

    def set_memory(self, mem):
        LOG.debug("Setting %i(%s)" % (mem.number, mem.extd_number))
        if mem.number < 0:
            # special channels
            val = str(RT23_SPECIAL[mem.number + len(RT23_SPECIAL)])
            _mem = getattr(self._memobj, val)
            #_nam = None
            #_scn = None
            #_usd = None
            if re.match('^rpt', val):
                _special_enables = self._memobj.special_enables
                setattr(_special_enables, val + "_enable", True)
        else:
            _mem = self._memobj.channels[mem.number - 1]
            _nam = self._memobj.names[mem.number - 1]
            bitpos = (1 << ((mem.number - 1) % 8))
            bytepos = ((mem.number - 1) / 8)
            _scn = self._memobj.scanflags[bytepos]
            _usd = self._memobj.usedflags[bytepos]

        if mem.empty:
            _mem.set_raw("\xFF" * 16)
            if mem.number < 0:
                val = str(RT23_SPECIAL[mem.number + 6])
                _special_enables = self._memobj.special_enables
                setattr(_special_enables, val + "_enable", False)
                return
            else:
                _nam.name = ("\xFF" * 7)
                _usd &= ~bitpos
                _scn &= ~bitpos
                return
        else:
            if mem.number < 0:
                val = str(RT23_SPECIAL[mem.number + 6])
                _special_enables = self._memobj.special_enables
                setattr(_special_enables, val + "_enable", True)
            else:
                _usd |= bitpos

        if _mem.get_raw() == ("\xFF" * 16):
            LOG.debug("Initializing empty memory")
            _mem.set_raw("\x00" * 16)
            if _scn:
                _scn |= bitpos

        ##_mem.set_raw("\x00" * 16)

        _mem.rxfreq = mem.freq / 10

        if mem.duplex == "off":
            for i in range(0, 4):
                _mem.txfreq[i].set_raw("\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

        if mem.number >= 0:
            _namelength = self.get_features().valid_name_length
            for i in range(_namelength):
                try:
                    _nam.name[i] = mem.name[i]
                except IndexError:
                    _nam.name[i] = "\xFF"

            ####_mem.scan = mem.skip != "S"
            if mem.skip == "S":
                _scn &= ~bitpos
            else:
                _scn |= bitpos
        _mem.isnarrow = mem.mode == "NFM"

        ((txmode, txtone, txpol), (rxmode, rxtone, rxpol)) = \
            chirp_common.split_tone_encode(mem)
        self.encode_tone(_mem.txtone, txmode, txtone, txpol)
        self.encode_tone(_mem.rxtone, rxmode, rxtone, rxpol)

        _mem.highpower = mem.power == RT23_POWER_LEVELS[1]

        for setting in mem.extra:
            setattr(_mem, setting.get_name(), setting.value)

    def get_settings(self):
        ####_keys = self._memobj.keys
        _settings = self._memobj.settings
        _mem = self._memobj
        basic = RadioSettingGroup("basic", "Basic Settings")
        advanced = RadioSettingGroup("advanced", "Advanced Settings")
        other = RadioSettingGroup("other", "Other Settings")
        workmode = RadioSettingGroup("workmode", "Workmode Settings")
        fmradio = RadioSettingGroup("fmradio", "FM Radio Settings")
        top = RadioSettings(basic, advanced, other, workmode, fmradio)

        #step = RadioSetting("step", "Step", RadioSettingValueList(
        #                    LIST_STEP, LIST_STEP[_settings.step]))
        #basic.append(step)

        save = RadioSetting("save", "Battery Saver",
                            RadioSettingValueBoolean(_settings.save))
        basic.append(save)

        vox = RadioSetting("vox", "VOX Gain",
                           RadioSettingValueList(
                               LIST_VOX, LIST_VOX[_settings.vox]))
        basic.append(vox)

        squelch = RadioSetting("squelch", "Squelch Level",
                               RadioSettingValueInteger(
                                   0, 9, _settings.squelch))
        basic.append(squelch)

        relay = RadioSetting("relay", "Repeater",
                             RadioSettingValueBoolean(_settings.relay))
        basic.append(relay)

        tot = RadioSetting("tot", "Time-out timer", RadioSettingValueList(
                           LIST_TOT, LIST_TOT[_settings.tot]))
        basic.append(tot)

        beep = RadioSetting("beep", "Key Beep",
                            RadioSettingValueBoolean(_settings.beep))
        basic.append(beep)

        color = RadioSetting("color", "Background Color", RadioSettingValueList(
                             LIST_COLOR, LIST_COLOR[_settings.color - 1]))
        basic.append(color)

        vot = RadioSetting("vot", "VOX Delay Time", RadioSettingValueList(
                           LIST_VOT, LIST_VOT[_settings.vot]))
        basic.append(vot)

        dwait = RadioSetting("dwait", "Dual Standby",
                             RadioSettingValueBoolean(_settings.dwait))
        basic.append(dwait)

        led = RadioSetting("led", "Background Light", RadioSettingValueList(
                           LIST_LED, LIST_LED[_settings.led]))
        basic.append(led)

        voice = RadioSetting("voice", "Voice Prompt", RadioSettingValueList(
                             LIST_VOICE, LIST_VOICE[_settings.voice]))
        basic.append(voice)
        
        roger = RadioSetting("roger", "Roger Beep",
                             RadioSettingValueBoolean(_settings.roger))
        basic.append(roger)

        autolk = RadioSetting("autolk", "Auto Key Lock",
                              RadioSettingValueBoolean(_settings.autolk))
        basic.append(autolk)

        opnset = RadioSetting("opnset", "Power On Message",
                              RadioSettingValueList(
                                  LIST_OPNSET, LIST_OPNSET[_settings.opnset]))
        basic.append(opnset)

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

        _msg = self._memobj.poweron_msg
        ponmsg = RadioSetting("poweron_msg.line1", "Power-On Message 1",
                              RadioSettingValueString(
                                  0, 7, _filter(_msg.line1)))
        basic.append(ponmsg)


        scans = RadioSetting("scans", "Scan Mode", RadioSettingValueList(
                             LIST_SCANS, LIST_SCANS[_settings.scans]))
        basic.append(scans)

        dw = RadioSetting("dw", "FM Radio Dual Watch",
                          RadioSettingValueBoolean(_settings.dw))
        basic.append(dw)

        name = RadioSetting("name", "Display Names",
                            RadioSettingValueBoolean(_settings.name))
        basic.append(name)

        rptrl = RadioSetting("rptrl", "Repeater TX Delay", RadioSettingValueList(
                             LIST_RPTRL, LIST_RPTRL[_settings.rptrl]))
        basic.append(rptrl)

        rptspk = RadioSetting("rptspk", "Repeater Speaker",
                              RadioSettingValueBoolean(_settings.rptspk))
        basic.append(rptspk)

        rptptt = RadioSetting("rptptt", "Repeater PTT Switch",
                            RadioSettingValueBoolean(_settings.rptptt))
        basic.append(rptptt)

        rptmod = RadioSetting("rptmod", "Repeater Mode",
                              RadioSettingValueList(
                                  LIST_RPTMOD, LIST_RPTMOD[_settings.rptmod]))
        basic.append(rptmod)

        volmod = RadioSetting("volmod", "Volume Mode",
                              RadioSettingValueList(
                                  LIST_VOLMOD, LIST_VOLMOD[_settings.volmod]))
        basic.append(volmod)

        dst = RadioSetting("dst", "DTMF Side Tone",
                            RadioSettingValueBoolean(_settings.dst))
        basic.append(dst)

        txsel = RadioSetting("txsel", "Priority TX Channel",
                             RadioSettingValueList(
                                 LIST_TXSEL, LIST_TXSEL[_settings.txsel]))
        basic.append(txsel)

        ste = RadioSetting("ste", "Squelch Tail Eliminate",
                           RadioSettingValueBoolean(_settings.ste))
        basic.append(ste)

        #advanced
        if _settings.pf1 > 0x0A:
            val = 0x00
        else:
            val = _settings.pf1
        pf1 = RadioSetting("pf1", "PF1 Key",
                           RadioSettingValueList(
                               LIST_PFKEY, LIST_PFKEY[val]))
        advanced.append(pf1)

        if _settings.pf2 > 0x0A:
            val = 0x00
        else:
            val = _settings.pf2
        pf2 = RadioSetting("pf2", "PF2 Key",
                           RadioSettingValueList(
                               LIST_PFKEY, LIST_PFKEY[val]))
        advanced.append(pf2)

        # other
        _limit = str(int(_mem.limits.vhf.lower) / 10)
        val = RadioSettingValueString(0, 3, _limit)
        val.set_mutable(False)
        rs = RadioSetting("limits.vhf.lower", "VHF low", val)
        other.append(rs)

        _limit = str(int(_mem.limits.vhf.upper) / 10)
        val = RadioSettingValueString(0, 3, _limit)
        val.set_mutable(False)
        rs = RadioSetting("limits.vhf.upper", "VHF high", val)
        other.append(rs)

        _limit = str(int(_mem.limits.uhf.lower) / 10)
        val = RadioSettingValueString(0, 3, _limit)
        val.set_mutable(False)
        rs = RadioSetting("limits.uhf.lower", "UHF low", val)
        other.append(rs)

        _limit = str(int(_mem.limits.uhf.upper) / 10)
        val = RadioSettingValueString(0, 3, _limit)
        val.set_mutable(False)
        rs = RadioSetting("limits.uhf.upper", "UHF high", val)
        other.append(rs)

        #work mode
        vfomr_a = RadioSetting("vfomr_a", "Display Mode A",
                               RadioSettingValueList(
                                   LIST_VFOMR, LIST_VFOMR[_settings.vfomr_a]))
        workmode.append(vfomr_a)

        vfomr_b = RadioSetting("vfomr_b", "Display Mode B",
                               RadioSettingValueList(
                                   LIST_VFOMR, LIST_VFOMR[_settings.vfomr_b]))
        workmode.append(vfomr_b)

        mrcha = RadioSetting("mrcha", "Channel # A",
                             RadioSettingValueInteger(
                                 1, 128, _settings.mrcha))
        workmode.append(mrcha)

        mrchb = RadioSetting("mrchb", "Channel # B",
                             RadioSettingValueInteger(
                                 1, 128, _settings.mrchb))
        workmode.append(mrchb)

        #fm radio
        vfomr_fm = RadioSetting("vfomr_fm", "FM Radio Display Mode",
                                RadioSettingValueList(
                                    LIST_VFOMRFM, LIST_VFOMRFM[_settings.vfomr_fm]))
        fmradio.append(vfomr_fm)

        fmch = RadioSetting("fmch", "FM Radio Channel #",
                            RadioSettingValueInteger(
                                 1, 25, _settings.fmch))
        fmradio.append(fmch)

        return top

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

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

    @classmethod
    def match_model(cls, filedata, filename):
        match_size = False
        match_model = False

        # testing the file data size
        if len(filedata) in [0x1000, ]:
            match_size = True

        # testing the model fingerprint
        match_model = model_match(cls, filedata)

        if match_size and match_model:
            return True
        else:
            return False