/*

    Copyright 2025 Joel Svensson  svenssonjoel@yahoo.se

    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/>.

*/

#include <extensions.h>

#include <lbm_image.h>

#include <heap.h>

#include <env.h>

#include <lbm_flat_value.h>

#include <eval_cps.h>

#include <extensions.h>

// Assumptions about the image memory:

// * It is part of the address space.

// * Image is always available at the same address (across reboots)

// * It is a write-once memory.

// * Can be cleared in its entirety.

// * Can check on a byte-level is "is-writable" (has a known initial state when cleared)

// Details

// * @const_start @const_end is tricky.

// * Constant heap is needed because of small amount of RAM.

// * Arbitrary pointers will be tricky.

// Want to be able to build an image incrementally.

// Can @const_start @const_end be used in conjuction with a

// more exlicit image manipulation subsystem.

//TBD:

// * does an image contain running threads ? (I would prefer if no)

//   instead there is a startup-entry that represents some code that will

//   be executed after setting up an image.

//   This startup-entry can spawn threads and initialize resources.

// * Will we have a heap-image or will all bindings move into the const heap.

// FEB 26:

// -- There will be no "heap-image" or "memory-image"

//    Just flattened and stored bindings from the environment (which is as good but likely smaller).

// -- There will be an image of the const-heap. in fact the const heap lives in the image always.

//    A bit problematic with building on image incrementally as it is in flash and the contents cannot be changed.

//    Contents can be added though!  (keep track of const-heap write-ptr is an issue)

// -- Maybe we should implement image for a read-write memory and then make the flash situation a special case?

// -- Maybe size fields should always be in bytes.

// -- TODO: a flatten function that flattens a value directly to flash and also does not flatten things that are

//          already in flash, but rather then just refers to them.

// FEB 27:

// -- Symbol numbering will be an issue.

//    * Store the symboltable in the image and restore it on boot.

//    * Names already in flash can be refered to.

//    * Names in ram can be copied.

//    * Entire subtable may already be in flash - leave in place and refer to it.

// -- loading an image and then adding to it can be tricky to make possible.

//    * const-heap write pointer needs to be stored. (but if it is stored then it cannot be changed)

//      Could allow multiple "const-heap-write-pointer" fields in the image and use the one that appears last...

//    * Symboltable could be created incrementally in a similar way. Append later symbol_table data fields

//      to the previously loaded.

// FEB 28:

// -- Symbol numbering problem. The structure of the symboltable may

//    need to change. It is currently impossible to append a symbol list stored

//    in flash to the global symbol table. A richer structure is needed.

// -- The symbols in the SYMTAB can all be in flash (all in the image) and

//    all name strings can be written to flash as well.

//    * May be easiest if names go to the flash heap (as it is now)

//      and table entries are a tagged field in the image (1 extra byte per symbol...)

//    * Means the image must be initialized (to a degree) before symbols are created.

// MARCH 1:

// -- Symbols are added to and restored from the image.

// -- lbm_add_symbol_const, still creates a lbm_memory list structure.

//    Const symbols should also be stored into the image and add_symbol_const

//    should check and reuse stored symbol id.

//    Check order of initialization to see how easy this is to fix.

// Offline image tools

// - Image compaction: remove overwrite fields and compact the image.

// - Change of base address: relabel all memory accesses.

// - ...

// MARCH 5

// -- Can constants (anything on const heap) contain references into non-constant heap?

//    - I think not, but should verify this.

//    - eval_cps move_to_flash performs a deep copy into flash.

// Endianess woes...

// - little endian     least-significant byte at least address

// - big endian        most-significant byte at least address

// - all platforms we target currently are little-endian

//

//  0x11223344

//     | | | '--- [44] addr

//     | | '----- [33] addr + 1

//     | '------- [22] addr + 2

//     '--------- [11] addr + 3

//

// Images are going to be mainly little endian.  (what endianess does flatvalues use? I think BE)

// constant heap should be 4byte aligned so that there are 2 unused low end bits

// in all cell-pointers into constant heap.

// March 8

// -- flattening lead to duplication of shared nodes.

//    if a = '(1 2 3) and b = (cons 4 a) and c = (cons 5 a)

//    then the result of flattening a b c each contains a full copy of a.

// -- flattening a value that in turn points to a constant value, duplicates

//    the constant value.

//  TODO: Put more info into the IMAGE_INITIALIZED FIELD

//        - 32/64 bit  etc

#ifdef LBM64

#define IMAGE_INITIALIZED (uint32_t)0xBEEF4001    // [ 0xBEEF4001 ]

#else

#define IMAGE_INITIALIZED (uint32_t)0xBEEF2001    // [ 0xBEEF2001 ]

#endif

                                            // Address downwards ->

#define CONSTANT_HEAP_IX  (uint32_t)0x02    // [ 0x02 | uint32]

#define BINDING_CONST     (uint32_t)0x03    // [ 0x03 | key | lbm_uint ]

#define BINDING_FLAT      (uint32_t)0x04    // [ 0x04 | size | key | flatval ]

#define STARTUP_ENTRY     (uint32_t)0x05    // [ 0x05 | symbol ])

#define SYMBOL_ENTRY      (uint32_t)0x06    // [ 0x06 | NEXT_PTR |  ID | NAME PTR ] // symbol_entry with highest address is root.

#define SYMBOL_LINK_ENTRY (uint32_t)0x07    // [ 0x07 | C_LINK_PTR | NEXT_PTR | ID | NAME PTR ]

#define EXTENSION_TABLE   (uint32_t)0x08    // [ 0x08 | NUM | EXT ...]

#define VERSION_ENTRY     (uint32_t)0x09    // [ 0x09 | size | string ]

// Size is in number of 32bit words, even on 64 bit images.

// To be able to work on an image incrementally (even though it is not recommended)

// many fields are allowed to be duplicated and the later ones have priority

// over earlier ones.

#define DOWNWARDS true

#define UPWARDS   false

static lbm_image_write_fun image_write = NULL;

static uint32_t *image_address = NULL;

static int32_t write_index = 0;

static uint32_t image_size = 0;

static bool image_has_extensions = false;

static char* image_version = NULL;

}

}

}

}

}

  // image_addres is an u32 ptr. so addr + i is a step of i * 4 bytes

}

}

  // downwards   ... hw   lw

  //                 ix  ix-1

  // upwards     hw   lw ...

  //            ix+1  ix

  // true = downwards

  } else {

  }

}

// fv_write function write values as big endian.

uint32_t fv_buf_ix = 0;

uint8_t  fv_buf[4] = {0};

  }

}

  else {

  }

}

  return

}

   return

}

#ifdef LBM64

  return write_u64(ptr_val, i, direction);

#else

#endif

}

#ifdef LBM64

  return write_u64(v, i, direction);

#else

#endif

}

// ////////////////////////////////////////////////////////////

// Flatten a value into image

// TODO: Consants things that are stored in the image

//       does not need to be flattened. Could refer to these by

//       reference. Some new kinds of flat values needs to be added

//       for this referencing to work.

// TODO: Symbols in a flat_value in an image can be stored as

//       its numerical representation rather than its string rep.

}

  // arrays are smaller than 2^32 elements long

}

  #ifndef LBM64

  #else

  r = r && fv_write_u64(sym_id);

  #endif

}

#ifndef LBM64

#else

  res = res && fv_write_u8(S_I56_VALUE);

  res = res && fv_write_u64((uint64_t)i);

#endif

}

#ifndef LBM64

#else

  res = res && fv_write_u8(S_U56_VALUE);

  res = res && fv_write_u64((uint64_t)u);

#endif

}

}

}

}

  uint32_t u;

}

  uint64_t u;

}

}

}

// num_bytes is specifically an uint32_t

    }

  }

}

  }

  }

    }

  }

}

  }

#ifdef LBM64

    *acc = *acc && fv_write_u64((lbm_uint)v);

#else

#endif

  }

    } else {

      // hmm

    }

    }

  }

}

}

                        // trav_ok = no cycles in input value.

}

// ////////////////////////////////////////////////////////////

//

  } else {

    }

  }

}

// ////////////////////////////////////////////////////////////

// Constant heaps as part of an image.

lbm_const_heap_t image_const_heap;

lbm_uint image_const_heap_start_ix = 0;

#ifdef LBM64

  int32_t i = (int32_t)(image_const_heap_start_ix + (ix * 2));

  uint32_t *words = (uint32_t*)&w;

  bool r = image_write(words[0], i, false);

  r = r && image_write(words[1], i + 1, false);

  return r;

#else

#endif

}

// ////////////////////////////////////////////////////////////

// Image manipulation

  // 64 bit                             | 32 bit

  // image[i] = SYMBOL_ENTRY            | image[i] = SYMBOL_ENTRY

  // image[i-1] = symlist_ptr_high_word | image[i-1] = symlist_ptr

  // image[i-2] = symlist_ptr_low_word  | image[i-2] = id

  // image[i-3] = id_high_word          | image[i-3] = name_ptr

  // image[i-4] = id_low_word

  // image[i-5] = name_ptr_high_word

  // image[i-6] = name_ptr_low_word

}

// The symbol id is written to the link address upon image-boot

  // 64 bit                             | 32 bit

  // image[i] = SYMBOL_ENTRY            | image[i] = SYMBOL_ENTRY

  // image[i-1] = link_ptr_high         | image[i-1] link_ptr

  // image[i-2] = link_ptr_low          | image[i-2] = symlist_ptr

  // image[i-3] = symlist_ptr_high_word | image[i-3] = id

  // image[i-4] = symlist_ptr_low_word  | image[i-4] = name_ptr

  // image[i-5] = id_high_word

  // image[i-6] = id_low_word

  // image[i-7] = name_ptr_high_word

  // image[i-8] = name_ptr_low_word

}

        } else {

            }

	      // TODO: What error handling makes sense?

	    }

          } else {

          }

        }

      }

    }

  }

}

// The extension table is created at system startup.

// Extensions can also be added dynamically.

// Dynamically added extensions have names starting with "ext-"

// and their names are placed in RAM by the reader.

//

// Symbol_id -> index in extension table mapping

// is created as extensions are added.

// dynamic extensions are added after "built-in" extensions

// and have higher indices.

      lbm_uint addr;

      // when PIC, name pointers may move around

      // between restarts. It is also the case that

      // the FPTRs will move around as well.

      // This makes dynamic extensions useless on Linux.

      // Static extensions are fine as they will be re-added after image-boot

      // and faulty FPTRs will be replaced.

      //#ifdef __PIC__

      //r = store_symbol_name_flash(name_ptr, &addr);

      //if (!r) return r;

      //name_ptr = (char *)addr;

      //#else

      }

      //#endif

#ifdef LBM64

      r = r && write_u64((uint64_t)name_ptr, &write_index, DOWNWARDS);

      r = r && write_u64((uint64_t)extension_table[i].fptr, &write_index, DOWNWARDS);

#else

#endif

    }

  }

}

static uint32_t last_const_heap_ix = 0;

  }

}

}

                    uint32_t image_size_words,

                    lbm_image_write_fun image_write_fun) {

      }

      }

    }

    }

  }

  //process image

                          &image_const_heap,

                          (lbm_uint*)(image_address));

      // initialized is a one word field

      // on 64 bit           | on 32 bit

      // pos     -> key_high | pos     -> key

      // pos - 1 -> key_low  | pos - 1 -> val

      // pos - 2 -> val_high

      // pos - 3 -> val_low

#ifdef LBM64

      lbm_uint bind_key = read_u64(pos-1);

      lbm_uint bind_val = read_u64(pos-3);

      pos -= 4;

#else

#endif

      }

      // on 64 bit           | on 32 bit

      // pos     -> size     | pos     -> size

      // pos - 1 -> key_high | pos - 1 -> key

      // pos - 2 -> key_low

      //

      // size in 32 or 64 bit words.

#ifdef LBM64

      lbm_uint bind_key = read_u64(pos-2);

      pos -= 3;

#else

#endif

      lbm_flat_value_t fv;

      lbm_value unflattened;

      }

      }

      // on 64 bit                         | on 32 bit

      // pos     -> symlist_addr_high_word | pos     -> symlist_ptr

      // pos - 1 -> symlist_addr_low_word  | pos - 1 -> id

      // pos - 2 -> id_high_word           | pos - 2 -> name_ptr

      // pos - 3 -> id_low_word            |

      // pos - 4 -> name_ptr_high_word     |

      // pos - 5 -> name_ptr_low_word      |

#ifdef LBM64

      int32_t entry_pos = pos - 5;

      lbm_symrepr_set_symlist((lbm_uint*)(image_address + entry_pos));

      pos -= 6;

#else

#endif

      // on 64 bits                        | on 32 bit

      // pos     -> link_ptr_high          | pos     -> link_ptr

      // pos - 1 -> link_ptr_low           | pos - 1 -> symlist_ptr

      // pos - 2 -> symlist_addr_high_word | pos - 2 -> id

      // pos - 3 -> symlist_addr_low_word  | pos - 3 -> name_ptr;

      // pos - 4 -> id_high_word

      // pos - 5 -> id_low_word

      // pos - 6 -> name_ptr_high_word

      // pos - 7 -> name_ptr_low_word

      //int32_t entry_pos = pos - (int32_t)(3 * (sizeof(lbm_uint) / 4));

      lbm_uint link_ptr;

      lbm_uint sym_id;

#ifdef LBM64

      link_ptr = read_u64(pos-1);

      sym_id   = read_u64(pos-5);

      *((lbm_uint*)link_ptr) = sym_id;

      lbm_symrepr_set_symlist((lbm_uint*)(image_address + (pos - 7)));

      pos -= 8;

#else

#endif

      // on 64 bit                | on 32 bit

      // pos     -> name_ptr_high | pos     -> name_ptr

      // pos - 1 -> name_ptr_low  | pos - 1 -> fptr

      // pos - 2 -> fptr_high

      // pos - 3 -> fptr_low

        lbm_uint name;

        lbm_uint fptr;

#ifdef LBM64

        name = read_u64(pos-1);

        fptr = read_u64(pos-3);

        pos -= 4;

#else

#endif

      }

      break;

    }

  }

}