/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

package core

import (
	"bytes"
	"debug/elf"
	"encoding/binary"
	"fmt"
	"io"
	"os"

	"mynewt.apache.org/newt/util"
)

type CoreConvert struct {
	Source    *os.File
	Target    *os.File
	ImageHash []byte
	elfHdr    *elf.Header32
	phdrs     []*elf.Prog32
	data      [][]byte
}

const (
	COREDUMP_TLV_IMAGE = 1
	COREDUMP_TLV_MEM   = 2
	COREDUMP_TLV_REGS  = 3
)

const (
	COREDUMP_MAGIC = 0x690c47c3
)

type CoreDumpHdr struct {
	Magic uint32
	Size  uint32
}

type CoreDumpTlv struct {
	Type uint8
	pad  uint8
	Len  uint16
	Off  uint32
}

func NewCoreConvert() *CoreConvert {
	return &CoreConvert{}
}

func (cc *CoreConvert) readHdr() error {
	var hdr CoreDumpHdr

	hdr_buf := make([]byte, binary.Size(hdr))
	if hdr_buf == nil {
		return util.NewNewtError("Out of memory")
	}

	cnt, err := cc.Source.Read(hdr_buf)
	if err != nil {
		return util.NewNewtError(fmt.Sprintf("Error reading: %s", err.Error()))
	}
	if cnt != binary.Size(hdr) {
		return util.NewNewtError("Short read")
	}

	hdr.Magic = binary.LittleEndian.Uint32(hdr_buf[0:4])
	hdr.Size = binary.LittleEndian.Uint32(hdr_buf[4:8])

	if hdr.Magic != COREDUMP_MAGIC {
		return util.NewNewtError("Source file is not corefile")
	}
	return nil
}

func (cc *CoreConvert) readTlv() (*CoreDumpTlv, error) {
	var tlv CoreDumpTlv

	tlv_buf := make([]byte, binary.Size(tlv))
	if tlv_buf == nil {
		return nil, util.NewNewtError("Out of memory")
	}

	cnt, err := cc.Source.Read(tlv_buf)
	if err == io.EOF {
		return nil, nil
	}
	if err != nil {
		return nil, util.NewNewtError(fmt.Sprintf("Error reading: %s",
			err.Error()))
	}
	if cnt == 0 {
		return nil, nil
	}
	if cnt != binary.Size(tlv) {
		return nil, util.NewNewtError("Short read")
	}

	tlv.Type = uint8(tlv_buf[0])
	tlv.pad = uint8(tlv_buf[1])
	tlv.Len = binary.LittleEndian.Uint16(tlv_buf[2:4])
	tlv.Off = binary.LittleEndian.Uint32(tlv_buf[4:8])

	return &tlv, nil
}

func (cc *CoreConvert) makeElfHdr() {
	var hdr elf.Header32
	var phdr elf.Prog32
	var shdr elf.Section32

	copy(hdr.Ident[:], elf.ELFMAG)
	hdr.Ident[elf.EI_CLASS] = byte(elf.ELFCLASS32)
	hdr.Ident[elf.EI_DATA] = byte(elf.ELFDATA2LSB)
	hdr.Ident[elf.EI_VERSION] = byte(elf.EV_CURRENT)
	hdr.Ident[elf.EI_OSABI] = byte(elf.ELFOSABI_NONE)
	hdr.Ident[elf.EI_ABIVERSION] = 0
	hdr.Ident[elf.EI_PAD] = 0
	hdr.Type = uint16(elf.ET_CORE)
	hdr.Machine = uint16(elf.EM_ARM)
	hdr.Version = uint32(elf.EV_CURRENT)
	hdr.Entry = 0
	hdr.Phoff = uint32(binary.Size(hdr))
	hdr.Shoff = 0
	hdr.Flags = 0
	hdr.Ehsize = uint16(binary.Size(hdr))
	hdr.Phentsize = uint16(binary.Size(phdr))
	hdr.Phnum = uint16(len(cc.phdrs))
	hdr.Shentsize = uint16(binary.Size(shdr))
	hdr.Shnum = 0
	hdr.Shstrndx = uint16(elf.SHN_UNDEF)

	cc.elfHdr = &hdr
}

func (cc *CoreConvert) makeProgHdr(off uint32, mem []byte) {
	var phdr elf.Prog32

	memSz := uint32(len(mem))

	phdr.Type = uint32(elf.PT_LOAD)
	phdr.Off = 0 /* offset of data in file */
	phdr.Vaddr = off
	phdr.Paddr = 0
	phdr.Filesz = memSz
	phdr.Memsz = memSz
	phdr.Flags = uint32(elf.PF_R)
	phdr.Align = 4

	cc.phdrs = append(cc.phdrs, &phdr)
	if memSz%4 != 0 {
		pad := make([]byte, 4-memSz%4)
		mem = append(mem, pad...)
	}
	cc.data = append(cc.data, mem)
}

func (cc *CoreConvert) makeRegData(regs []byte) []byte {
	type Elf32_Note struct {
		Namesz uint32
		Descsz uint32
		Ntype  uint32
	}

	type Elf32_Prstatus struct {
		Dummy  [18]uint32
		Regs   [18]uint32
		Dummy2 uint32
	}

	var note Elf32_Note
	var sts Elf32_Prstatus

	idx := 0
	for off := 0; off < len(regs); off += 4 {
		reg := binary.LittleEndian.Uint32(regs[off : off+4])
		sts.Regs[idx] = reg
		idx++
		if idx >= 18 {
			break
		}
	}

	noteName := ".reg"
	noteLen := len(noteName) + 1
	if noteLen%4 != 0 {
		noteLen = noteLen + 4 - (noteLen % 4)
	}
	noteBytes := make([]byte, noteLen)
	copy(noteBytes[:], noteName)

	note.Namesz = uint32(len(noteName) + 1) /* include terminating '\0' */
	note.Descsz = uint32(binary.Size(sts))
	note.Ntype = uint32(elf.NT_PRSTATUS)

	buffer := new(bytes.Buffer)
	binary.Write(buffer, binary.LittleEndian, note)
	buffer.Write(noteBytes)
	binary.Write(buffer, binary.LittleEndian, sts)
	return buffer.Bytes()
}

func (cc *CoreConvert) makeRegInfo(regs []byte) {
	var phdr elf.Prog32

	phdr.Type = uint32(elf.PT_NOTE)
	phdr.Off = 0
	phdr.Vaddr = 0
	phdr.Paddr = 0
	phdr.Filesz = 0
	phdr.Memsz = 0
	phdr.Flags = 0
	phdr.Align = 4

	data := cc.makeRegData(regs)
	phdr.Filesz = uint32(len(data))

	cc.phdrs = append(cc.phdrs, &phdr)
	cc.data = append(cc.data, data)
}

func (cc *CoreConvert) setProgHdrOff() {
	off := binary.Size(cc.elfHdr)
	off += len(cc.phdrs) * binary.Size(cc.phdrs[0])

	for idx, phdr := range cc.phdrs {
		phdr.Off = uint32(off)
		off += len(cc.data[idx])
	}
}

func (cc *CoreConvert) Convert() error {
	if cc.Source == nil || cc.Target == nil {
		return util.NewNewtError("Missing file parameters")
	}

	err := cc.readHdr()
	if err != nil {
		return err
	}

	for {
		tlv, err := cc.readTlv()
		if err != nil {
			return err
		}
		if tlv == nil {
			break
		}
		data_buf := make([]byte, tlv.Len)
		cnt, err := cc.Source.Read(data_buf)
		if err != nil {
			return util.NewNewtError(fmt.Sprintf("Error reading: %s",
				err.Error()))
		}
		if cnt != int(tlv.Len) {
			return util.NewNewtError("Short file")
		}
		switch tlv.Type {
		case COREDUMP_TLV_MEM:
			cc.makeProgHdr(tlv.Off, data_buf)
		case COREDUMP_TLV_IMAGE:
			cc.ImageHash = data_buf
		case COREDUMP_TLV_REGS:
			if tlv.Len%4 != 0 {
				return util.NewNewtError("Invalid register area size")
			}
			cc.makeRegInfo(data_buf)
		default:
			return util.NewNewtError("Unknown TLV type")
		}
	}
	cc.makeElfHdr()
	if err != nil {
		return err
	}
	cc.setProgHdrOff()

	binary.Write(cc.Target, binary.LittleEndian, cc.elfHdr)
	for _, phdr := range cc.phdrs {
		binary.Write(cc.Target, binary.LittleEndian, phdr)
	}
	for _, data := range cc.data {
		cc.Target.Write(data)
	}
	return nil
}

func ConvertFilenames(srcFilename string,
	dstFilename string) (*CoreConvert, error) {

	coreConvert := NewCoreConvert()

	var err error

	coreConvert.Source, err = os.OpenFile(srcFilename, os.O_RDONLY, 0)
	if err != nil {
		return coreConvert, util.FmtNewtError("Cannot open file %s - %s",
			srcFilename, err.Error())
	}
	defer coreConvert.Source.Close()

	coreConvert.Target, err = os.OpenFile(dstFilename,
		os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0660)
	if err != nil {
		return coreConvert, util.FmtNewtError("Cannot open file %s - %s",
			dstFilename, err.Error())
	}
	defer coreConvert.Target.Close()

	if err := coreConvert.Convert(); err != nil {
		return coreConvert, err
	}

	return coreConvert, nil
}