import { AwaitStore, Lock } from "@hibas123/utils";
import * as fs from "fs";
import * as path from "path";
import { Adapter, Message, Formatted, LoggingTypes } from "@hibas123/logging";
import { once } from "events";

const MAX_FILE_SIZE = 500000000;

export class FileAdapter implements Adapter {
   level = LoggingTypes.Debug;

   file: Files;
   isInit = new AwaitStore(false);
   constructor(private filename: string, private maxFileSize = MAX_FILE_SIZE) {}

   setLevel(level: LoggingTypes) {
      this.level = level;
   }

   async init() {
      if (!this.file) {
         this.file = Files.getFile(this.filename);
         await this.file
            .init(this.maxFileSize)
            .then(() => this.isInit.send(true));
      }
   }

   flush(sync: boolean) {
      // return this.file.flush(sync);
   }

   onMessage(message: Message) {
      let msg = Buffer.from(Formatted.strip(message.text) + "\n");
      this.file.write(msg);
   }

   async close() {
      if (this.file) {
         await this.file.close();
         this.file = undefined;
      }
      this.isInit.send(false);
   }
}

//TODO: Optimise write path

const Debounce = (callback: () => void, iv = 500, max = 100) => {
   let to: any;
   let curr = 0;

   return {
      trigger: () => {
         curr++;
         if (curr >= max) {
            curr = 0; // not clearing timeout, since this is a very high cost operation
            callback();
         } else if (!to) {
            to = setTimeout(() => {
               to = undefined;
               curr = 0;
               callback();
            }, iv);
         }
      },
   };
};

const QUEUE_START_SIZE = 10000;

export class Files {
   private static files = new Map<string, Files>();
   static getFile(filename: string): Files {
      filename = path.resolve(filename);
      let file = this.files.get(filename);
      if (!file) {
         file = new Files(filename);
         this.files.set(filename, file);
      }
      file.open++;
      return file;
   }

   private open = 0;

   #maxFileSize = MAX_FILE_SIZE;
   #size: number = 0;
   #stream: fs.WriteStream = undefined;
   #lock = new Lock();
   #debounce = Debounce(this.checkQueue.bind(this));
   #initialized = false;
   #queue: Buffer[] = new Array(QUEUE_START_SIZE);
   #queueIdx = 0;

   public get initlialized() {
      return this.#initialized;
   }

   private constructor(private file: string) {}

   public async init(maxFileSize: number) {
      if (this.#initialized) return;
      this.#maxFileSize = maxFileSize;

      let lock = await this.#lock.getLock();

      const folder = path.dirname(this.file);
      if (folder) {
         if (!(await fsExists(folder))) {
            await fsMkDir(folder).catch(() => {}); //Could happen, if two seperate instances want to create the same folder so ignoring
         }
      }

      await this.initializeFile();
      this.#initialized = true;
      await this.checkQueue(true);
      lock.release();
   }

   private async initializeFile(new_file = false) {
      try {
         if (this.#stream) {
            const closePrms = once(this.#stream, "close");

            this.#stream.end();

            await closePrms;
         }

         let size = 0;
         if (await fsExists(this.file)) {
            let stats = await fsStat(this.file);
            if (new_file || stats.size >= this.#maxFileSize) {
               if (await fsExists(this.file + ".old"))
                  await fsUnlink(this.file + ".old");
               await fsMove(this.file, this.file + ".old");
            } else {
               size = stats.size;
            }
         }

         this.#stream = fs.createWriteStream(this.file, { flags: "a" });
         this.#size = size;
      } catch (err) {
         console.log(err);
         //TODO: is this the right behavior? Probably not...
         process.exit(1);
      }
   }

   private async checkQueue(nolock: boolean = false) {
      let lock: any;
      if (nolock == false) {
         //TODO: New design might cause new messages to be "stalled" till close or another message
         if (this.#lock.locked) return;
         lock = await this.#lock.getLock();
      }

      const queue = this.#queue;
      const queueCnt = this.#queueIdx;

      this.#queue = new Array(QUEUE_START_SIZE);
      this.#queueIdx = 0;

      let buffer = Buffer.alloc(1024 * 128);
      let ci = 0;
      for (let i = 0; i < queueCnt; i++) {
         const entry = queue[i];

         if (entry.length + ci > buffer.length) {
            await this.write_to_file(buffer.slice(0, ci));
            ci = 0;
            if (entry.length > buffer.length) {
               await this.write_to_file(entry);
            } else {
               entry.copy(buffer, ci);
               ci += entry.length;
            }
         } else {
            entry.copy(buffer, ci);
            ci += entry.length;
         }
      }

      if (ci > 0) {
         await this.write_to_file(buffer.slice(0, ci));
      }

      if (lock) lock.release();
   }

   public async close() {
      //TODO: maybe some raceconditions when open collides with close
      const lock = await this.#lock.getLock();
      await this.checkQueue(true);
      this.open--;
      if (this.open <= 0) {
         const a = once(this.#stream, "close");
         this.#stream.close();
         await a;
         Files.files.delete(this.file);
      }
      lock.release();
   }

   private async write_to_file(data: Buffer) {
      try {
         if (
            data.byteLength < this.#maxFileSize &&
            this.#size + data.byteLength > this.#maxFileSize
         ) {
            await this.initializeFile(true);
         }
         this.#size += data.byteLength;
         this.#stream.write(data);
      } catch (err) {
         // TODO: Better error handling!
         console.error(err);
         this.initializeFile(false);
         this.write_to_file(data);
      }
   }

   public write(data: Buffer) {
      this.#queue[this.#queueIdx++] = data;
      this.#debounce.trigger();
   }
}

function fsUnlink(path: string) {
   if (fs.promises?.unlink) {
      return fs.promises.unlink(path);
   }
   return new Promise<void>((resolve, reject) => {
      fs.unlink(path, (err) => {
         if (err) reject(err);
         else resolve();
      });
   });
}

function fsStat(path: string) {
   if (fs.promises?.stat) {
      return fs.promises.stat(path);
   }
   return new Promise<fs.Stats>((resolve, reject) => {
      fs.stat(path, (err, stats) => {
         if (err) reject(err);
         else resolve(stats);
      });
   });
}

function fsMove(oldPath: string, newPath: string) {
   return new Promise<void>((resolve, reject) => {
      let callback = (err?) => {
         if (err) reject(err);
         else resolve();
      };

      fs.rename(oldPath, newPath, function (err) {
         if (err) {
            if (err.code === "EXDEV") {
               copy();
            } else {
               callback(err);
            }
            return;
         }
         callback();
      });

      function copy() {
         fs.copyFile(oldPath, newPath, (err) => {
            if (err) callback(err);
            else fs.unlink(oldPath, callback);
         });
      }
   });
}

function fsExists(path: string) {
   return new Promise<boolean>((resolve, reject) => {
      fs.access(path, (err) => resolve(!err));
   });
}

function fsMkDir(path: string) {
   return new Promise<void>((resolve, reject) => {
      fs.mkdir(path, (err) => (err ? reject(err) : resolve()));
   });
}