import anyTest from 'ava';
import { TypedTestFn, hardcodedReusableTestUsers } from './utils';
import { createTestContext } from './utils';
import { db } from 'db/drizzle';
import { user } from 'db/schema';
import { eq } from 'drizzle-orm';

const test = anyTest as TypedTestFn

test.before(async t => {
    t.context = await createTestContext()
})
test.serial('Create', async t => {
    t.timeout(2000)
    const newUser = await t.context.callers.admin.client.create({
        userData: {
            password: 'ABCD',
            phone: '666424324321231',
            name: 'TESTIMUS MAXIMUS',
            email: 'whatever@sdfafdsafewafsda.com'
        },
        note: 'idk this is optional',
        discountData: {
            flatValue: 10,
            percentage: 1,
        }
    })

    console.log('newUser: ', newUser)
    // t.notThrowsAsync(t.context.callers.admin.client.create({
    //     userData: {
    //         password: 'ABCD',
    //         phone: '666424324321231',
    //         name: 'TESTIMUS MAXIMUS',
    //         email: 'whatever@sdfafdsafewafsda.com'
    //     },
    //     note: 'idk this is optional',
    //     discountData: {
    //         flatValue: 10,
    //         percentage: 1,
    //     }
    // }))
    // t.is(1,1)
    t.pass('All good I hope')
    t.teardown(async () => {
        console.log('doin teardown')
        await t.context.db.delete(user).where(eq(user.id, newUser.userId))
        console.log('teardown done')
    })
} );

test.after.always(async () => {
    console.log('AFTER start')
    await db.delete(user).where(eq(user.phone, hardcodedReusableTestUsers.user.phone))
    await db.delete(user).where(eq(user.phone, hardcodedReusableTestUsers.admin.phone))
    
    console.log('AFTER DONE')
    
})

import { type TestFn } from 'ava';
import { db } from '../db/drizzle';
import { client, user } from 'db/schema';
import { appRouter, t, emptyContextMethods } from '../trpc/index';
import { eq } from 'drizzle-orm';


export const createApiCaller = t.createCallerFactory(appRouter)


export const hardcodedReusableTestUsers = {
    user: {
        name: 'UserName1321',
        phone: '1111',
        email: 'user.kekimus1111@test.com',
        password: 'whatever'
    },
    admin: {
        name: 'AdminUserName1230',
        phone: '0000',
        email: 'adminUser.kekimus0000@test.com',
        password: 'test_admin_user_password',
        isAdmin: true
    }
}


export const createTestContext = async (shouldThrowAway: boolean = false) => {

    const [testUserFromDb] = await db.insert(user).values({
        ...hardcodedReusableTestUsers.user
    }).returning()
    const [testAdminUserFromDb] = await db.insert(user).values({
        ...hardcodedReusableTestUsers.admin
    }).returning()

    const [testUserClient] = await db.insert(client).values({
        userId: testUserFromDb.id
    }).returning()
    const [testAdminUserClient] = await db.insert(client).values({
        userId: testAdminUserFromDb.id
    }).returning()

    if(shouldThrowAway) {
        await db.delete(user).where(eq(user.id, testUserFromDb.id))
        await db.delete(user).where(eq(user.id, testAdminUserFromDb.id))
        await db.delete(client).where(eq(client.id, testUserClient.id))
        await db.delete(client).where(eq(client.id, testAdminUserClient.id))
    }

    const testUser = {
        ...testUserFromDb,
        client: testUserClient
    }

    const testAdminUser = {
        ...testAdminUserFromDb,
        client: testAdminUserClient
    }
    return {
        db: db,
        callers: {
            authed: createApiCaller({
                ...emptyContextMethods,
                userAgent: 'TestUserAgent',
                user: testUser,
                db,
            }),
            notAuthed: createApiCaller({
                ...emptyContextMethods,
                userAgent: undefined,
                user: undefined,
                db,
            }),
            admin: createApiCaller({
                ...emptyContextMethods,
                userAgent: 'TestAdminUserAgent',
                user: testAdminUser,
                db
            })

        }
    }

}

const exampleContextSoICanInferTyping = await createTestContext(true)

export type TestContextType = typeof exampleContextSoICanInferTyping

export type TypedTestFn = TestFn<TestContextType>