# Copyright 2011 Dan Smith <dsmith@danplanet.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 3 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 logging

from chirp import util, memmap, chirp_common, bitwise, directory, errors
from yaesu_clone import YaesuCloneModeRadio

LOG = logging.getLogger(__name__)

CHUNK_SIZE = 16


def _send(s, data):
    for i in range(0, len(data), CHUNK_SIZE):
        chunk = data[i:i+CHUNK_SIZE]
        s.write(chunk)
        echo = s.read(len(chunk))
        if chunk != echo:
            raise Exception("Failed to read echo chunk")

IDBLOCK1 = "\x0c\x01\x41\x33\x35\x02\x00\xb8"  #Unmodified USA Radio
IDBLOCK2 = "\x0c\x01\x41\x33\x35\x03\x00\xb9"  #USA Radio modified for extended TX

IDBLOCK = [IDBLOCK1,IDBLOCK2]
TRAILER = "\x0c\x02\x41\x33\x35\x00\x00\xb7"
ACK = "\x0C\x06\x00"

my_idblock = IDBLOCK[0]  #default IDBLOCK

def _download(radio):
    data = ""
    for _i in range(0, 10):
        data = radio.pipe.read(8)
        #print(':'.join(data.encode('hex') for x in 'Hello World!'))
        print(util.hexprint(data))
        #if data == IDBLOCK:
        if data in IDBLOCK:
            my_idblock = data
            break

    LOG.debug("Header:\n%s" % util.hexprint(data))

    if len(data) != 8:
        raise Exception("Failed to read header")

    _send(radio.pipe, ACK)

    data = ""

    while len(data) < radio._block_sizes[1]:
        time.sleep(0.1)
        chunk = radio.pipe.read(38)
        LOG.debug("Got: %i:\n%s" % (len(chunk), util.hexprint(chunk)))
        if len(chunk) == 8:
            LOG.debug("END?")
        elif len(chunk) != 38:
            LOG.debug("Should fail?")
            break
            # raise Exception("Failed to get full data block")
        else:
            cs = 0
            for byte in chunk[:-1]:
                cs += ord(byte)
            if ord(chunk[-1]) != (cs & 0xFF):
                raise Exception("Block failed checksum!")

            data += chunk[5:-1]

        _send(radio.pipe, ACK)
        if radio.status_fn:
            status = chirp_common.Status()
            status.max = radio._block_sizes[1]
            status.cur = len(data)
            status.msg = "Cloning from radio"
            radio.status_fn(status)

    LOG.debug("Total: %i" % len(data))
    print(util.hexprint(data))
    return my_idblock, memmap.MemoryMap(data)


def _upload(radio):
    for _i in range(0, 10):
        data = radio.pipe.read(256)
        if not data:
            break
        LOG.debug("What is this garbage?\n%s" % util.hexprint(data))
    
    _send(radio.pipe,radio.radio_id)
    
    time.sleep(1)
    ack = radio.pipe.read(300)
    LOG.debug("Ack was (%i):\n%s" % (len(ack), util.hexprint(ack)))
    if ack != ACK:
        raise Exception("Radio did not ack ID")

    block = 0
    while block < (radio.get_memsize() / 32):
        data = "\x0C\x03\x00\x00" + chr(block)
        data += radio.get_mmap()[block*32:(block+1)*32]
        cs = 0
        for byte in data:
            cs += ord(byte)
        data += chr(cs & 0xFF)

        LOG.debug("Writing block %i:\n%s" % (block, util.hexprint(data)))

        _send(radio.pipe, data)
        time.sleep(0.1)
        ack = radio.pipe.read(3)
        if ack != ACK:
            raise Exception("Radio did not ack block %i" % block)

        if radio.status_fn:
            status = chirp_common.Status()
            status.max = radio._block_sizes[1]
            status.cur = block * 32
            status.msg = "Cloning to radio"
            radio.status_fn(status)
        block += 1

    _send(radio.pipe, TRAILER)

MEM_FORMAT = """
struct {
  bbcd freq[4];
  u8 unknown1[4];
  bbcd offset[2];
  u8 unknown2[2];
  u8 pskip:1,
     skip:1,
     unknown3:1,
     isnarrow:1,
     power:2,
     duplex:2;
  u8 unknown4:6,
     tmode:2;
  u8 tone;
  u8 dtcs;
} memory[200];

#seekto 0x0E00;
struct {
  char name[6];
} names[200];
"""

MODES = ["FM", "NFM"]
TMODES = ["", "Tone", "TSQL", "DTCS"]
DUPLEX = ["", "-", "+", ""]
POWER_LEVELS = [chirp_common.PowerLevel("Hi", watts=65),
                chirp_common.PowerLevel("Mid", watts=25),
                chirp_common.PowerLevel("Low2", watts=10),
                chirp_common.PowerLevel("Low1", watts=5),
                ]
CHARSET = chirp_common.CHARSET_UPPER_NUMERIC + "()+-=*/???|_"


@directory.register
class FT2800Radio(YaesuCloneModeRadio):
    """Yaesu FT-2800"""
    VENDOR = "Yaesu"
    MODEL = "FT-2800M"

    _block_sizes = [8, 7680]
    _memsize = 7680

    def get_features(self):
        rf = chirp_common.RadioFeatures()

        rf.memory_bounds = (0, 199)

        rf.has_ctone = False
        rf.has_tuning_step = False
        rf.has_dtcs_polarity = False
        rf.has_bank = False

        rf.valid_tuning_steps = [5.0, 10.0, 12.5, 15.0,
                                 20.0, 25.0, 50.0, 100.0]
        rf.valid_modes = MODES
        rf.valid_tmodes = TMODES
        rf.valid_bands = [(137000000, 174000000)]
        rf.valid_power_levels = POWER_LEVELS
        rf.valid_duplexes = DUPLEX
        rf.valid_skips = ["", "S", "P"]
        rf.valid_name_length = 6
        rf.valid_characters = CHARSET

        return rf

    def sync_in(self):
        self.pipe.parity = "E"
        start = time.time()
        try:
            self.radio_id, self._mmap = _download(self)
        except errors.RadioError:
            raise
        except Exception, e:
            raise errors.RadioError("Failed to communicate with radio: %s" % e)
        LOG.info("Downloaded in %.2f sec" % (time.time() - start))
        self.process_mmap()

    def sync_out(self):
        self.pipe.timeout = 1
        self.pipe.parity = "E"
        start = time.time()
        try:
            _upload(self)
        except errors.RadioError:
            raise
        except Exception, e:
            raise errors.RadioError("Failed to communicate with radio: %s" % e)
        LOG.info("Uploaded in %.2f sec" % (time.time() - start))

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

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

    def get_memory(self, number):
        _mem = self._memobj.memory[number]
        _nam = self._memobj.names[number]
        mem = chirp_common.Memory()

        mem.number = number

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

        mem.freq = int(_mem.freq) * 10
        mem.offset = int(_mem.offset) * 100000
        mem.duplex = DUPLEX[_mem.duplex]
        mem.tmode = TMODES[_mem.tmode]
        mem.rtone = chirp_common.TONES[_mem.tone]
        mem.dtcs = chirp_common.DTCS_CODES[_mem.dtcs]
        mem.name = str(_nam.name).rstrip()
        mem.mode = _mem.isnarrow and "NFM" or "FM"
        mem.skip = _mem.pskip and "P" or _mem.skip and "S" or ""
        mem.power = POWER_LEVELS[_mem.power]

        return mem

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

        if mem.empty:
            _mem.set_raw("\xFF" * (_mem.size() / 8))
            return

        if _mem.get_raw()[0] == "\xFF":
            # Emtpy -> Non-empty, so initialize
            _mem.set_raw("\x00" * (_mem.size() / 8))

        _mem.freq = mem.freq / 10
        _mem.offset = mem.offset / 100000
        _mem.duplex = DUPLEX.index(mem.duplex)
        _mem.tmode = TMODES.index(mem.tmode)
        _mem.tone = chirp_common.TONES.index(mem.rtone)
        _mem.dtcs = chirp_common.DTCS_CODES.index(mem.dtcs)
        _mem.isnarrow = MODES.index(mem.mode)
        _mem.pskip = mem.skip == "P"
        _mem.skip = mem.skip == "S"
        if mem.power:
            _mem.power = POWER_LEVELS.index(mem.power)
        else:
            _mem.power = 0

        _nam.name = mem.name.ljust(6)[:6]

    @classmethod
    def match_model(cls, filedata, filename):
        return len(filedata) == cls._memsize