Texture mapping procedural mesh with texture atlas? (Minecraft style terrain gen)

Hey guys, I'm currently working on a small learning project where I'm trying to recreate minecraft style terrain gen. It's been going well so far, however, I've hit a brick wall with texturing different block faces with different textures.

Heres what my terrain looks like at the minute:

As you can see, I've managed to get a single texture UV mapped on all sides of the cube fine, however I just can't seem to figure out how to make each face use a different texture.

Here's my terrain generation code:

  public void RenderChunk()
     {
         Mesh mesh = GetComponent<MeshFilter>().mesh;
         mesh.Clear(false);
 
         //Clear Lists
         vertices.Clear();
         uvs.Clear();
         triangles.Clear();
 
         foreach (KeyValuePair<Vector3, TYPE> position in positions)
         {
             if (position.Value == TYPE.BLOCK)
             {
                 List<int> neededVerts = CheckAdjacentPositions(position.Key);
                 if (neededVerts.Count > 0)
                 {
                     Block block = new Block();
                     List<Vector3> verts_ = block.GetBlockVertices(position.Key, neededVerts);
 
                     int vcount = 0;
                     int face = 0; //0 = front, 1 = back, 2 = top, 3 = bottom, 4 = right, 5 = left
                     int tri = 0; //Current triangle
                     int lastTri = 0; //Previous triangle
                     int firstIndex = 0; //First index to check.
 
                     foreach (Vector3 v in verts_)
                     {
                         vertices.Add(v);
                         triangles.Add(vertices.Count-1);
 
                         //Check which face the next six verts represent by checking the first 2 vertices of face.
                         if ((vcount == 0 || tri != lastTri))
                         {
 
                             if (neededVerts[firstIndex] == 0 && neededVerts[firstIndex + 1] == 2)
                                 face = 0;
                             else if (neededVerts[firstIndex] == 5 && neededVerts[firstIndex + 1] == 4)
                                 face = 1;
                             else if (neededVerts[firstIndex] == 0 && neededVerts[firstIndex + 1] == 7)
                                 face = 5;
                             else if (neededVerts[firstIndex] == 1 && neededVerts[firstIndex + 1] == 2)
                                 face = 4;
                             else if (neededVerts[firstIndex] == 2 && neededVerts[firstIndex + 1] == 3)
                                 face = 2;
                             else if (neededVerts[firstIndex] == 0 && neededVerts[firstIndex + 1] == 6)
                                 face = 3;
                             else
                             {
                                 Debug.Log(neededVerts[firstIndex] + "??" + neededVerts[firstIndex + 1] + "    " + firstIndex);
                             }
                             lastTri = tri;
 
                         }
 
                         //Assigns UVs based of face. Each number represents a face, break down of this is given above. 
                         if (face == 0 || face == 1)
                             uvs.Add(new Vector2(v.y, v.x));
                         else if (face == 2 || face == 3)
                             uvs.Add(new Vector2(v.x, v.z));
                         else if (face == 4 || face == 5)
                             uvs.Add(new Vector2(v.z, v.y));
                        
 
                       
                         //Increment vert count
                         if (vcount >=  5)
                         {
                             tri++;
                             vcount = 0;
                             firstIndex += 6;
                         }
                         else
                             vcount++;
 
                     }
                 }
             }
         }
 
         Vector3[] verts = new Vector3[(vertices.Count)];
         int[] tris = new int[triangles.Count];
         Vector2[] uvmap = new Vector2[uvs.Count];
 
 
         //Convert Vertices, Triangles and UV's lists into arrays.
         for (int i = 0; i < vertices.Count ; i++)
             verts[i] = vertices[i];
 
         for (int t = 0; t < triangles.Count ; t++)
             tris[t] = triangles[t];
 
         for (int z = 0; z < uvs.Count; z++)
             uvmap[z] = uvs[z];
 
         //Build the mesh
         mesh.vertices = verts;
         mesh.triangles = tris;
         mesh.uv = uvmap;
         mesh.Optimize();
         mesh.RecalculateNormals();
         GetComponent<MeshCollider>().sharedMesh = mesh;
 
     }

The code pretty much checks loops through all of the blocks in a chunk, checking which faces are visible and adding them to the mesh. I then check which face a vertice is a part of and assign the appropriate UV. This is perfect to get the single texture mapped, but is useless for what I want to get done.

If anyone has any experience with this or has any ideas of what I can try to fix this it would be much appreciated :) thanks.