import { Effect, Function, Pipeable, Predicate, Readable } from "effect"
import type { NoInfer } from "effect/Types"


/**
 * @category type ids
 */
export const TypeId: unique symbol = Symbol.for("@effect-fc/Writable")

/**
 * @category type ids
 */
export type TypeId = typeof TypeId

/**
 * Represents a value that can be written to.
 *
 * Dual to `Readable`, which represents a value that can be read.
 * A `Writable<A, E, R>` exposes a `set` operation that accepts a value of type
 * `A` and returns an `Effect<void, E, R>`.
 *
 * @category models
 */
export interface Writable<in A, E = never, R = never> extends Pipeable.Pipeable {
    readonly [TypeId]: TypeId
    readonly set: (value: A) => Effect.Effect<void, E, R>
}

/**
 * A `ReadWritable` is both `Readable` and `Writable` — it can be both read
 * from and written to.
 *
 * @category models
 */
export interface ReadWritable<in out A, E = never, R = never>
    extends Readable.Readable<A, E, R>, Writable<A, E, R> {}

/**
 * @category refinements
 */
export const isWritable = (u: unknown): u is Writable<unknown, unknown, unknown> =>
    Predicate.hasProperty(u, TypeId)

const Proto: Pick<Writable<unknown, unknown, unknown>, typeof TypeId | "pipe"> = {
    [TypeId]: TypeId,
    pipe(...args: Array<unknown>) {
        return Pipeable.pipeArguments(this, args as any)
    },
}

/**
 * Construct a `Writable` from a `set` function.
 *
 * @category constructors
 */
export const make = <A, E, R>(set: (value: A) => Effect.Effect<void, E, R>): Writable<A, E, R> => {
    const self = Object.create(Proto) as Writable<A, E, R>
    ;(self as any).set = set
    return self
}

/**
 * Construct a `ReadWritable` from a `get` effect and a `set` function.
 *
 * @category constructors
 */
export const makeReadWritable = <A, E, R>(options: {
    readonly get: Effect.Effect<A, E, R>
    readonly set: (value: A) => Effect.Effect<void, E, R>
}): ReadWritable<A, E, R> => {
    const self = Object.create(Proto) as ReadWritable<A, E, R>
    ;(self as any).get = options.get
    ;(self as any).set = options.set
    ;(self as any)[Readable.TypeId] = Readable.TypeId
    return self
}

/**
 * Transform the input of a `Writable` using a pure function.
 * The resulting `Writable` accepts values of type `B`, maps them to `A` with
 * `f`, and then forwards them to the original `set`.
 *
 * @category combinators
 */
export const contramap: {
    <B, A>(f: (b: NoInfer<B>) => A): <E, R>(self: Writable<A, E, R>) => Writable<B, E, R>
    <A, E, R, B>(self: Writable<A, E, R>, f: (b: NoInfer<B>) => A): Writable<B, E, R>
} = Function.dual(2, <A, E, R, B>(self: Writable<A, E, R>, f: (b: B) => A): Writable<B, E, R> =>
    make((b: B) => self.set(f(b)))
)

/**
 * Transform the input of a `Writable` using an effectful function.
 *
 * @category combinators
 */
export const contramapEffect: {
    <B, A, E2, R2>(f: (b: NoInfer<B>) => Effect.Effect<A, E2, R2>): <E, R>(self: Writable<A, E, R>) => Writable<B, E | E2, R | R2>
    <A, E, R, B, E2, R2>(self: Writable<A, E, R>, f: (b: NoInfer<B>) => Effect.Effect<A, E2, R2>): Writable<B, E | E2, R | R2>
} = Function.dual(2, <A, E, R, B, E2, R2>(self: Writable<A, E, R>, f: (b: B) => Effect.Effect<A, E2, R2>): Writable<B, E | E2, R | R2> =>
    make((b: B) => Effect.flatMap(f(b), (a) => self.set(a)))
)

/**
 * Unwrap a `Writable` that is wrapped in an `Effect`.
 *
 * @category constructors
 */
export const unwrap = <A, E, R, E1, R1>(
    effect: Effect.Effect<Writable<A, E, R>, E1, R1>,
): Writable<A, E | E1, R | R1> =>
    make((value: A) => Effect.flatMap(effect, (w) => w.set(value)))