using var scope = Py.CreateScope();

scope.Exec(
"""
import sys

class NetConsole(object):
    def __init__(self, writeCallback):
        self.writeCallback = writeCallback

    def write(self, message):
        self.writeCallback(message)

    def flush(self):
        pass

def setConsoleOut(writeCallback):
    sys.stdout = NetConsole(writeCallback)
"""
);

dynamic setConsoleOutFn = scope.Get("setConsoleOut");

var writeCallbackFn = (string message) => {
    if (message != "\n")
        Console.Write("[Py]: ");

    Console.Write(message);
};

setConsoleOutFn(writeCallbackFn);

scope.Eval("print('hello world')");

import sys

class NetConsole(object):
    @CSnakes.Replaceble
    def write(self, message: str) -> None:
        raise Exception("not replaced with dotnet yet")

    @CSnakes.Replaceble
    def flush(self) -> None:
        raise Exception("not replaced with dotnet yet")

sys.stdout = NetConsole()

class PythonEngineer : IDisposable 
{
   // generic implementation, maybe also generic static functions usable as the developer likes
}

class NetConsoleEngineer : PythonEngineer 
{
   NetConsoleEngineer(PyObject c,           // python object which defines the class to replace 
                      string attribute);    // name of the class
  
  // does this initializer work for functions defined outside classes too, like c is a PyDict etc. ?
 
   NetConsoleEngineer InjectWrite(Action<PyObject, string> f) 
   { 
      /* get and store the original python function
         internal calls like 
           PythonEngineerCallable<PyObject, string>.CreateFor("def write(self, message: str) -> None:", f) 
         to construct the PyFunction as the callback
         replace the original function with the callback */ 

      return this; // enable call chains
   }
   NetConsoleEngineer EjectWrite() 
   { 
     /* restore the original python function and release and null its reference */
    return this;  
   }

  NetConsoleEngineer InjectFlush(Action<PyObject> f) { /* ... */ return this; }
  NetConsoleEngineer EjectFlush(PyObject c) { /* ... */ return this; }
}

using var engineer = new NetConsoleEngineer(pyCode, "NetConsole");

engineer
  .InjectWrite( (self, message) => {
    Console.Write(message); 
  })
  .InjectFlush( (self) => {} );

// now the engineer instance holds references to the original python functions

// run the python code ... when finished:

engineer
  .EjectWrite() // restores and PyDecRef on python function
  .EjectFlush(); 

// dispose of engineer does PyDecRef on pyCode (after all not yet callbacks are ejected)

// this might look like more code than pythonnet, but it also sets the flush callback too...
// and as the pythonnet code does the cleanup automically (does it??), 
// so the Eject calls could be left away here  too

class NetConsoleEngineer 
{
   void InjectWrite(Action<NetConsoleEngineer, PyObject, string> f); 
}

class MyNetConsoleEngineer : NetConsoleEngineer
{
    string SomeValue { get; set; }
}

using var engineer = new MyNetConsoleEngineer(pyCode, "NetConsole") { SomeValue = "?" };

engineer.InjectWrite( (e, self, message) => {
  var myNetConsoleEngineer = e as MyNetConsoleEngineer;
  Console.Write(message + myNetConsoleEngineer.SomeValue); 
});

class NetConsoleEngineer 
{
  NetConsoleEngineer(PyObject c, string attribute, object anything);
   void InjectWrite(Action<object, PyObject, string> f); 
}

using var engineer = new NetConsoleEngineer (pyCode, "NetConsole", "?");

engineer.InjectWrite( (value, self, message) => {
  Console.Write(message + value); 
});

class NetConsoleEngineer 
{
  NetConsoleEngineer(PyObject c, string attribute, object anything);
   void InjectWrite(Action<object, nint, nint>); 
}

List<nint> messages = new();

using var engineer = new NetConsoleEngineer (pyCode, "NetConsole", messages);

engineer.InjectWrite( (messages, self, message) => { 
  CAPI.PyIncRef(message);
  ((List<nint>)messages).Append(message); 
});

class PythonEngineer 
{
  static PyFunc GeneratePyFuncWrappingAsyncPyFunc(PyFunc F, PyFunc pyResultCallback , PyFunc pyIsCancelledCallback)
  {
    // return a generated python function which:
    //   "takes" the C# callbacks to an awaitable queue and cancellation token, either by arguments 
    // or being called using a given locals dict etc. ...

    // the generated python function does something like:

    //    try: 
    //       result = await F() # F can abort/return on if pyIsCancelledCallback() is True
    //                          # will work as result = F() too... 
    //                          # but await shown as a way to combine C# async with CPython async
    //    except Exception:
    //       pass # should be given back too?? maybe a Tuple of result,ex ??
    //    finally:
    //      pyResultCallback(result) # enqueue into awaitable C# queue
  }
}

class PythonExecutor<T> 
{
  static async Task<T> CallPythonAsync(PyFunc f, CancellationToken token=CancellationToken.None)
  {
    // should be a predefined as much as possible, like do not parse the function definition each time...
    var pyIsCancelledCallback = PythonEngineerCallable<Func<bool>>.CreateFor(
      "def f() -> bool:",  
      () => {
         return token.IsCancellationRequested(); // that would use automatic marshalling for the result
      }
    );
   
     var  resultQueue = new AsyncQueue<T>();
  
    var pythonType = PythonEngineer.PythonTypeString(T); // if something like that is possible somehow..., 
                                                         // should give back "int" if the generics T is int
  
    var pyResultCallback = PythonEngineerCallable<Action<T>>.CreateFor(
     $"def f(x: {pythonType}) -> None:",
     (x) => {
      resultQueue.Enqueue(x);
     }
    );
  
    var syncPyFunc = PythonEngineer.GeneratePyFuncWrappingAsyncPyFunc(f, pyResultCallback, pyIsCancelledCallback);
  
   //
   // give the python interpreter the syncPyFunc to execute in a "fire and forget" manner
   //

   // at this point we don;t need to hold any references to the python callbacks anymore 
   // as they will be kept alive by python itself
   //
   // is that ensured by catching all exceptions? or will this leak if the python interpreter is brought down "somehow"? 
   // in such case - are non leaking async calls possible anyway?
  
     return await resultQueue.DequeueAsync(token); // throw exception: await tuple and check for it...
  }
}

import asyncio
import random

def async asyncAiFunc() -> int:
   await asyncio.sleep(20)
   # how to access and call pyIsCancelledCallback() for code running in a loop etc. ??

   # for a "hard" termination of a python thread (if executed in one, see later) there might 
   # be a CPython API call which injects signals or so
   # but something like that would be implemented on the C# side on a different level...

   return random.choice([ 42, 23 ])

var asyncPythonFunc = pythonObject.GetAttr("asyncAiFunc");
var result = await PythonExecutor<int>.CallPythonAsync(asyncPythonFunc);

// would be "usefull" if arguments to the Python func could be passed too... 

var result = await  pythonObject.GetAttr("asyncAiFunc").CalledAsync(); // where does the <int> etc. go ?